diff --git a/frontend/src/components/sidebar.tsx b/frontend/src/components/sidebar.tsx
index 703dc14..efa9c88 100644
--- a/frontend/src/components/sidebar.tsx
+++ b/frontend/src/components/sidebar.tsx
@@ -5,18 +5,30 @@ import {
Smartphone,
Box,
Atom,
- Database,
- FolderOpen
+ FolderOpen,
+ Bird,
+ Code2,
+ Cog,
+ Zap,
+ Package,
+ Container,
+ Coffee
} from 'lucide-react'
-// Category definitions
+// Category definitions
const CATEGORIES = [
- { id: 'all', name: 'All Items', icon: FolderOpen, color: 'text-gray-400', bgColor: 'bg-gray-500/10', types: ['xcode', 'android', 'node', 'react-native', 'cache'] },
+ { id: 'all', name: 'All Items', icon: FolderOpen, color: 'text-gray-400', bgColor: 'bg-gray-500/10', types: ['xcode', 'android', 'node', 'react-native', 'flutter', 'python', 'rust', 'go', 'homebrew', 'docker', 'java'] },
{ id: 'xcode', name: 'Xcode', icon: Apple, color: 'text-blue-400', bgColor: 'bg-blue-500/10', types: ['xcode'] },
{ id: 'android', name: 'Android', icon: Smartphone, color: 'text-green-400', bgColor: 'bg-green-500/10', types: ['android'] },
{ id: 'node', name: 'Node.js', icon: Box, color: 'text-yellow-400', bgColor: 'bg-yellow-500/10', types: ['node'] },
{ id: 'react-native', name: 'React Native', icon: Atom, color: 'text-cyan-400', bgColor: 'bg-cyan-500/10', types: ['react-native'] },
- { id: 'cache', name: 'Cache', icon: Database, color: 'text-purple-400', bgColor: 'bg-purple-500/10', types: ['cache'] },
+ { id: 'flutter', name: 'Flutter', icon: Bird, color: 'text-blue-500', bgColor: 'bg-blue-600/10', types: ['flutter'] },
+ { id: 'python', name: 'Python', icon: Code2, color: 'text-blue-600', bgColor: 'bg-blue-700/10', types: ['python'] },
+ { id: 'rust', name: 'Rust', icon: Cog, color: 'text-orange-500', bgColor: 'bg-orange-500/10', types: ['rust'] },
+ { id: 'go', name: 'Go', icon: Zap, color: 'text-cyan-500', bgColor: 'bg-cyan-600/10', types: ['go'] },
+ { id: 'homebrew', name: 'Homebrew', icon: Package, color: 'text-amber-500', bgColor: 'bg-amber-500/10', types: ['homebrew'] },
+ { id: 'docker', name: 'Docker', icon: Container, color: 'text-sky-500', bgColor: 'bg-sky-500/10', types: ['docker'] },
+ { id: 'java', name: 'Java', icon: Coffee, color: 'text-red-600', bgColor: 'bg-red-600/10', types: ['java'] },
] as const
// CSS styles as objects to avoid Tailwind issues
@@ -101,19 +113,31 @@ const styles = {
const colorMap: Record
= {
'text-gray-400': '#9ca3af',
'text-blue-400': '#60a5fa',
+ 'text-blue-500': '#3b82f6',
+ 'text-blue-600': '#2563eb',
'text-green-400': '#4ade80',
'text-yellow-400': '#facc15',
'text-cyan-400': '#22d3ee',
- 'text-purple-400': '#c084fc',
+ 'text-cyan-500': '#06b6d4',
+ 'text-orange-500': '#f97316',
+ 'text-amber-500': '#f59e0b',
+ 'text-sky-500': '#0ea5e9',
+ 'text-red-600': '#dc2626',
}
const bgColorMap: Record = {
'bg-gray-500/10': 'rgba(107, 114, 128, 0.1)',
'bg-blue-500/10': 'rgba(59, 130, 246, 0.1)',
+ 'bg-blue-600/10': 'rgba(37, 99, 235, 0.1)',
+ 'bg-blue-700/10': 'rgba(29, 78, 216, 0.1)',
'bg-green-500/10': 'rgba(34, 197, 94, 0.1)',
'bg-yellow-500/10': 'rgba(234, 179, 8, 0.1)',
'bg-cyan-500/10': 'rgba(6, 182, 212, 0.1)',
- 'bg-purple-500/10': 'rgba(168, 85, 247, 0.1)',
+ 'bg-cyan-600/10': 'rgba(8, 145, 178, 0.1)',
+ 'bg-orange-500/10': 'rgba(249, 115, 22, 0.1)',
+ 'bg-amber-500/10': 'rgba(245, 158, 11, 0.1)',
+ 'bg-sky-500/10': 'rgba(14, 165, 233, 0.1)',
+ 'bg-red-600/10': 'rgba(220, 38, 38, 0.1)',
}
export function Sidebar() {
@@ -129,13 +153,13 @@ export function Sidebar() {
}
const isCategoryActive = (types: readonly string[]) => {
- if (types.length === 5 && typeFilter.length === 0) return true
+ if (types.length === 11 && typeFilter.length === 0) return true
if (typeFilter.length === 0) return false
return JSON.stringify([...types].sort()) === JSON.stringify([...typeFilter].sort())
}
const handleClick = (types: readonly string[]) => {
- setTypeFilter(types.length === 5 ? [] : [...types])
+ setTypeFilter(types.length === 11 ? [] : [...types])
}
return (
@@ -152,6 +176,11 @@ export function Sidebar() {
const iconColor = colorMap[cat.color] || '#888'
const iconBg = bgColorMap[cat.bgColor] || 'rgba(100,100,100,0.1)'
+ // Hide category if no items (except "All Items")
+ if (cat.id !== 'all' && stats.count === 0) {
+ return null
+ }
+
return (
{
setScanning(true)
try {
- // Get settings for MaxDepth
- let maxDepth = 5;
+ // Get settings to use same scan options as auto-scan
+ let settings;
try {
- const settings = await GetSettings();
- if (settings.maxDepth) maxDepth = settings.maxDepth;
+ settings = await GetSettings();
} catch (e) {
- console.warn("Could not load settings for scan, using default depth", e);
+ console.warn("Could not load settings for scan, using defaults", e);
}
- const opts = new types.ScanOptions({
- IncludeXcode: true,
- IncludeAndroid: true,
- IncludeNode: true,
- IncludeReactNative: true,
- IncludeCache: true,
- MaxDepth: maxDepth,
- ProjectRoot: '/Users' // Scan /Users directory
- })
-
+ const opts = createDefaultScanOptions(settings)
await Scan(opts)
toast({
@@ -81,18 +70,16 @@ export function Toolbar() {
// Clear selection
clearSelection()
- // Re-fetch scan results to update the list
- try {
- const results = await GetScanResults()
- setScanResults(results)
+ // Trigger a new scan to refresh the results
+ toast({
+ title: 'Clean Complete',
+ description: 'Rescanning to update results...'
+ })
- toast({
- title: 'Clean Complete',
- description: 'Files have been deleted successfully'
- })
- } catch (error) {
- console.error('Failed to refresh results:', error)
- }
+ // Wait a bit for file system to settle
+ setTimeout(async () => {
+ await handleScan()
+ }, 500)
}
return (
diff --git a/frontend/src/components/treemap-chart.tsx b/frontend/src/components/treemap-chart.tsx
index e5ec513..553a764 100644
--- a/frontend/src/components/treemap-chart.tsx
+++ b/frontend/src/components/treemap-chart.tsx
@@ -110,7 +110,6 @@ export function TreemapChart({ items, selectedPaths, onToggleSelection, classNam
const treemapItems = useMemo(() => {
return items
.sort((a, b) => b.size - a.size)
- .slice(0, 50) // Top 50 items
.map(item => ({
name: item.name || item.path.split('/').pop() || 'Unknown',
size: item.size,
@@ -129,7 +128,7 @@ export function TreemapChart({ items, selectedPaths, onToggleSelection, classNam
{/* Header */}
- Showing top {treemapItems.length} of {items.length} items
+ Showing {items.length} items
{selectedPaths.length > 0 && (
diff --git a/frontend/src/components/update-notification.tsx b/frontend/src/components/update-notification.tsx
new file mode 100644
index 0000000..09eaaed
--- /dev/null
+++ b/frontend/src/components/update-notification.tsx
@@ -0,0 +1,169 @@
+import { useState, useEffect } from 'react'
+import {
+ Dialog,
+ DialogContent,
+ DialogDescription,
+ DialogFooter,
+ DialogHeader,
+ DialogTitle,
+} from '@/components/ui/dialog'
+import { Button } from '@/components/ui/button'
+import { ExternalLink, Download } from 'lucide-react'
+import { CheckForUpdates } from '../../wailsjs/go/main/App'
+import { services } from '../../wailsjs/go/models'
+
+interface UpdateNotificationProps {
+ checkOnMount?: boolean
+}
+
+export function UpdateNotification({ checkOnMount = false }: UpdateNotificationProps) {
+ const [open, setOpen] = useState(false)
+ const [updateInfo, setUpdateInfo] = useState(null)
+
+ useEffect(() => {
+ if (checkOnMount) {
+ handleCheckForUpdates()
+ }
+ }, [checkOnMount])
+
+ const handleCheckForUpdates = async () => {
+ try {
+ const info = await CheckForUpdates()
+ setUpdateInfo(info)
+ if (info && info.available) {
+ setOpen(true)
+ }
+ } catch (error) {
+ console.error('Failed to check for updates:', error)
+ }
+ }
+
+ const handleDownload = () => {
+ if (updateInfo?.releaseURL) {
+ window.open(updateInfo.releaseURL, '_blank')
+ }
+ }
+
+ if (!updateInfo?.available) {
+ return null
+ }
+
+ return (
+
+ )
+}
+
+// Export a manual check button component
+export function CheckForUpdatesButton() {
+ const [checking, setChecking] = useState(false)
+ const [result, setResult] = useState<{ message: string; type: 'success' | 'info' | 'error' } | null>(null)
+
+ const handleCheck = async () => {
+ setChecking(true)
+ setResult(null)
+ try {
+ const info = await CheckForUpdates()
+ if (info?.available) {
+ setResult({
+ message: `Update available: ${info.latestVersion}`,
+ type: 'info'
+ })
+ } else {
+ setResult({
+ message: 'You are running the latest version',
+ type: 'success'
+ })
+ }
+ } catch (error) {
+ setResult({
+ message: 'Failed to check for updates',
+ type: 'error'
+ })
+ console.error('Update check failed:', error)
+ } finally {
+ setChecking(false)
+ }
+ }
+
+ const getTextColor = () => {
+ if (!result) return 'text-muted-foreground'
+ switch (result.type) {
+ case 'success':
+ return 'text-green-600 dark:text-green-500'
+ case 'info':
+ return 'text-blue-600 dark:text-blue-500'
+ case 'error':
+ return 'text-red-600 dark:text-red-500'
+ default:
+ return 'text-muted-foreground'
+ }
+ }
+
+ return (
+
+
+ {result && (
+
+ {result.message}
+
+ )}
+
+ )
+}
diff --git a/frontend/src/lib/scan-utils.ts b/frontend/src/lib/scan-utils.ts
new file mode 100644
index 0000000..0352f1a
--- /dev/null
+++ b/frontend/src/lib/scan-utils.ts
@@ -0,0 +1,35 @@
+import { types, services } from '../../wailsjs/go/models'
+
+/**
+ * Creates default scan options with all categories enabled
+ * This ensures consistent scan behavior across auto-scan and manual scan
+ */
+export function createDefaultScanOptions(settings?: services.Settings): types.ScanOptions {
+ const maxDepth = settings?.maxDepth || 5
+
+ return new types.ScanOptions({
+ // Development tools
+ IncludeXcode: true,
+ IncludeAndroid: true,
+ IncludeNode: true,
+ IncludeReactNative: true,
+ IncludeFlutter: true,
+ IncludeJava: true,
+
+ // Programming languages
+ IncludePython: true,
+ IncludeRust: true,
+ IncludeGo: true,
+
+ // System tools
+ IncludeHomebrew: true,
+ IncludeDocker: true,
+
+ // Cache (disabled by default to avoid false positives)
+ IncludeCache: false,
+
+ // Scan configuration
+ ProjectRoot: '/Users',
+ MaxDepth: maxDepth
+ })
+}
diff --git a/frontend/wailsjs/go/main/App.d.ts b/frontend/wailsjs/go/main/App.d.ts
index 5d95a3c..bd73920 100755
--- a/frontend/wailsjs/go/main/App.d.ts
+++ b/frontend/wailsjs/go/main/App.d.ts
@@ -1,13 +1,17 @@
// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH ร MODIWL
// This file is automatically generated. DO NOT EDIT
+import {services} from '../models';
import {types} from '../models';
import {cleaner} from '../models';
-import {services} from '../models';
+
+export function CheckForUpdates():Promise;
export function Clean(arg1:Array):Promise>;
export function ClearTreeCache():Promise;
+export function ClearUpdateCache():Promise;
+
export function GetScanResults():Promise>;
export function GetSettings():Promise;
diff --git a/frontend/wailsjs/go/main/App.js b/frontend/wailsjs/go/main/App.js
index 3d6b680..5b7360f 100755
--- a/frontend/wailsjs/go/main/App.js
+++ b/frontend/wailsjs/go/main/App.js
@@ -2,6 +2,10 @@
// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH ร MODIWL
// This file is automatically generated. DO NOT EDIT
+export function CheckForUpdates() {
+ return window['go']['main']['App']['CheckForUpdates']();
+}
+
export function Clean(arg1) {
return window['go']['main']['App']['Clean'](arg1);
}
@@ -10,6 +14,10 @@ export function ClearTreeCache() {
return window['go']['main']['App']['ClearTreeCache']();
}
+export function ClearUpdateCache() {
+ return window['go']['main']['App']['ClearUpdateCache']();
+}
+
export function GetScanResults() {
return window['go']['main']['App']['GetScanResults']();
}
diff --git a/frontend/wailsjs/go/models.ts b/frontend/wailsjs/go/models.ts
index 534ba90..d765319 100755
--- a/frontend/wailsjs/go/models.ts
+++ b/frontend/wailsjs/go/models.ts
@@ -32,6 +32,7 @@ export namespace services {
confirmDelete: boolean;
scanCategories: string[];
maxDepth: number;
+ checkAutoUpdate: boolean;
static createFrom(source: any = {}) {
return new Settings(source);
@@ -45,8 +46,50 @@ export namespace services {
this.confirmDelete = source["confirmDelete"];
this.scanCategories = source["scanCategories"];
this.maxDepth = source["maxDepth"];
+ this.checkAutoUpdate = source["checkAutoUpdate"];
}
}
+ export class UpdateInfo {
+ available: boolean;
+ currentVersion: string;
+ latestVersion: string;
+ releaseURL: string;
+ releaseNotes: string;
+ // Go type: time
+ publishedAt: any;
+
+ static createFrom(source: any = {}) {
+ return new UpdateInfo(source);
+ }
+
+ constructor(source: any = {}) {
+ if ('string' === typeof source) source = JSON.parse(source);
+ this.available = source["available"];
+ this.currentVersion = source["currentVersion"];
+ this.latestVersion = source["latestVersion"];
+ this.releaseURL = source["releaseURL"];
+ this.releaseNotes = source["releaseNotes"];
+ this.publishedAt = this.convertValues(source["publishedAt"], null);
+ }
+
+ convertValues(a: any, classs: any, asMap: boolean = false): any {
+ if (!a) {
+ return a;
+ }
+ if (a.slice && a.map) {
+ return (a as any[]).map(elem => this.convertValues(elem, classs));
+ } else if ("object" === typeof a) {
+ if (asMap) {
+ for (const key of Object.keys(a)) {
+ a[key] = new classs(a[key]);
+ }
+ return a;
+ }
+ return new classs(a);
+ }
+ return a;
+ }
+ }
}
diff --git a/go.mod b/go.mod
index 8edaf06..c3637a1 100644
--- a/go.mod
+++ b/go.mod
@@ -1,12 +1,13 @@
module github.com/thanhdevapp/dev-cleaner
-go 1.25.5
+go 1.24.0
require (
github.com/charmbracelet/bubbles v0.21.1-0.20250623103423-23b8fd6302d7
github.com/charmbracelet/bubbletea v1.3.10
github.com/charmbracelet/lipgloss v1.1.0
github.com/spf13/cobra v1.10.2
+ github.com/stretchr/testify v1.11.1
github.com/wailsapp/wails/v2 v2.11.0
)
@@ -18,6 +19,7 @@ require (
github.com/charmbracelet/x/ansi v0.10.1 // indirect
github.com/charmbracelet/x/cellbuf v0.0.13 // indirect
github.com/charmbracelet/x/term v0.2.1 // indirect
+ github.com/davecgh/go-spew v1.1.1 // indirect
github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
github.com/go-ole/go-ole v1.3.0 // indirect
github.com/godbus/dbus/v5 v5.1.0 // indirect
@@ -41,6 +43,7 @@ require (
github.com/muesli/termenv v0.16.0 // indirect
github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect
github.com/pkg/errors v0.9.1 // indirect
+ github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/rivo/uniseg v0.4.7 // indirect
github.com/samber/lo v1.49.1 // indirect
github.com/spf13/pflag v1.0.9 // indirect
@@ -55,4 +58,5 @@ require (
golang.org/x/net v0.37.0 // indirect
golang.org/x/sys v0.36.0 // indirect
golang.org/x/text v0.23.0 // indirect
+ gopkg.in/yaml.v3 v3.0.1 // indirect
)
diff --git a/go.sum b/go.sum
index 2f5e472..f527165 100644
--- a/go.sum
+++ b/go.sum
@@ -1,5 +1,7 @@
github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
+github.com/aymanbagabas/go-udiff v0.3.1 h1:LV+qyBQ2pqe0u42ZsUEtPiCaUoqgA9gYRDs3vj1nolY=
+github.com/aymanbagabas/go-udiff v0.3.1/go.mod h1:G0fsKmG+P6ylD0r6N/KgQD/nWzgfnl8ZBcNLgcbrw8E=
github.com/bep/debounce v1.2.1 h1:v67fRdBA9UQu2NhLFXrSg0Brw7CexQekrBwDMM8bzeY=
github.com/bep/debounce v1.2.1/go.mod h1:H8yggRPQKLUhUoqrJC1bO2xNya7vanpDl7xR3ISbCJ0=
github.com/charmbracelet/bubbles v0.21.1-0.20250623103423-23b8fd6302d7 h1:JFgG/xnwFfbezlUnFMJy0nusZvytYysV4SCS2cYbvws=
@@ -16,6 +18,8 @@ github.com/charmbracelet/x/ansi v0.10.1 h1:rL3Koar5XvX0pHGfovN03f5cxLbCF2YvLeyz7
github.com/charmbracelet/x/ansi v0.10.1/go.mod h1:3RQDQ6lDnROptfpWuUVIUG64bD2g2BgntdxH0Ya5TeE=
github.com/charmbracelet/x/cellbuf v0.0.13 h1:/KBBKHuVRbq1lYx5BzEHBAFBP8VcQzJejZ/IA3iR28k=
github.com/charmbracelet/x/cellbuf v0.0.13/go.mod h1:xe0nKWGd3eJgtqZRaN9RjMtK7xUYchjzPr7q6kcvCCs=
+github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91 h1:payRxjMjKgx2PaCWLZ4p3ro9y97+TVLZNaRZgJwSVDQ=
+github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91/go.mod h1:wDlXFlCrmJ8J+swcL/MnGUuYnqgQdW9rhSD61oNMb6U=
github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ=
github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg=
github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
@@ -35,6 +39,8 @@ github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2
github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e h1:Q3+PugElBCf4PFpxhErSzU3/PY5sFL5Z6rfv4AbGAck=
github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e/go.mod h1:alcuEEnZsY1WQsagKhZDsoPCRoOijYqhZvPwLG0kzVs=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/labstack/echo/v4 v4.13.3 h1:pwhpCPrTl5qry5HRdM5FwdXnhXSLSY+WE+YQSeCaafY=
github.com/labstack/echo/v4 v4.13.3/go.mod h1:o90YNEeQWjDozo584l7AwhJMHN0bOC4tAfg+Xox9q5g=
github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0=
@@ -68,6 +74,8 @@ github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELU
github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=
github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
@@ -84,8 +92,8 @@ github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY=
github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
github.com/tkrajina/go-reflector v0.5.8 h1:yPADHrwmUbMq4RGEyaOUpz2H90sRsETNVpjzo3DLVQQ=
github.com/tkrajina/go-reflector v0.5.8/go.mod h1:ECbqLgccecY5kPmPmXg1MrHW585yMcDkVl6IvJe64T4=
github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
@@ -122,5 +130,7 @@ golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/internal/services/clean_service_test.go b/internal/services/clean_service_test.go
new file mode 100644
index 0000000..91233bf
--- /dev/null
+++ b/internal/services/clean_service_test.go
@@ -0,0 +1,169 @@
+package services
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+ "github.com/thanhdevapp/dev-cleaner/pkg/types"
+)
+
+// TestNewCleanService tests CleanService initialization
+func TestNewCleanService(t *testing.T) {
+ // Test with dry-run enabled
+ service, err := NewCleanService(true)
+ require.NoError(t, err, "NewCleanService should not return error")
+ require.NotNil(t, service, "CleanService should not be nil")
+ assert.NotNil(t, service.cleaner, "Cleaner should be initialized")
+ assert.False(t, service.cleaning, "Should not be cleaning initially")
+
+ // Test with dry-run disabled
+ service2, err := NewCleanService(false)
+ require.NoError(t, err, "NewCleanService should not return error")
+ require.NotNil(t, service2, "CleanService should not be nil")
+}
+
+// TestCleanEmptyItems tests cleaning with empty items
+func TestCleanEmptyItems(t *testing.T) {
+ service, err := NewCleanService(true)
+ require.NoError(t, err)
+
+ // Try to clean empty items
+ var emptyItems []types.ScanResult
+ results, err := service.Clean(emptyItems)
+
+ assert.Error(t, err, "Should return error for empty items")
+ assert.Contains(t, err.Error(), "no items to clean", "Error should indicate no items")
+ assert.Nil(t, results, "Results should be nil for empty items")
+}
+
+// TestIsCleaning tests IsCleaning method
+func TestIsCleaning(t *testing.T) {
+ service, err := NewCleanService(true)
+ require.NoError(t, err)
+
+ // Initially not cleaning
+ assert.False(t, service.IsCleaning(), "Should not be cleaning initially")
+
+ // Set cleaning flag
+ service.cleaning = true
+ assert.True(t, service.IsCleaning(), "Should be cleaning after flag set")
+
+ // Unset cleaning flag
+ service.cleaning = false
+ assert.False(t, service.IsCleaning(), "Should not be cleaning after flag unset")
+}
+
+// TestConcurrentClean tests that concurrent cleans are prevented
+func TestConcurrentClean(t *testing.T) {
+ service, err := NewCleanService(true)
+ require.NoError(t, err)
+
+ // Set cleaning flag to simulate ongoing clean
+ service.mu.Lock()
+ service.cleaning = true
+ service.mu.Unlock()
+
+ // Try to clean while already cleaning
+ items := []types.ScanResult{
+ {Path: "/test/item1", Size: 1000, Type: types.TypeNode},
+ }
+
+ results, err := service.Clean(items)
+ assert.Error(t, err, "Should return error when clean already in progress")
+ assert.Contains(t, err.Error(), "clean already in progress", "Error message should indicate clean in progress")
+ assert.Nil(t, results, "Results should be nil when clean blocked")
+}
+
+// TestCleanNilItems tests cleaning with nil items slice
+func TestCleanNilItems(t *testing.T) {
+ service, err := NewCleanService(true)
+ require.NoError(t, err)
+
+ // Try to clean nil items (equivalent to empty slice)
+ results, err := service.Clean(nil)
+
+ assert.Error(t, err, "Should return error for nil items")
+ assert.Contains(t, err.Error(), "no items to clean", "Error should indicate no items")
+ assert.Nil(t, results, "Results should be nil for nil items")
+}
+
+// TestCleanFreedSpaceCalculation tests freed space calculation logic
+func TestCleanFreedSpaceCalculation(t *testing.T) {
+ // This test validates the freed space calculation logic
+ // that would be used in the Clean method
+ mockResults := []struct {
+ Success bool
+ Size int64
+ }{
+ {Success: true, Size: 1000},
+ {Success: true, Size: 2000},
+ {Success: false, Size: 500}, // Failed - should not count
+ {Success: true, Size: 3000},
+ {Success: false, Size: 1000}, // Failed - should not count
+ }
+
+ var freedSpace int64
+ successCount := 0
+
+ for _, r := range mockResults {
+ if r.Success {
+ freedSpace += r.Size
+ successCount++
+ }
+ }
+
+ // Verify calculations
+ assert.Equal(t, int64(6000), freedSpace, "Should sum only successful deletions (1000+2000+3000)")
+ assert.Equal(t, 3, successCount, "Should count only successful deletions")
+}
+
+// TestCleanValidation tests input validation
+func TestCleanValidation(t *testing.T) {
+ service, err := NewCleanService(true)
+ require.NoError(t, err)
+
+ testCases := []struct {
+ name string
+ items []types.ScanResult
+ shouldError bool
+ errorMsg string
+ }{
+ {
+ name: "Empty slice",
+ items: []types.ScanResult{},
+ shouldError: true,
+ errorMsg: "no items to clean",
+ },
+ {
+ name: "Nil slice",
+ items: nil,
+ shouldError: true,
+ errorMsg: "no items to clean",
+ },
+ {
+ name: "Valid items",
+ items: []types.ScanResult{
+ {Path: "/test/item1", Size: 1000, Type: types.TypeNode},
+ },
+ shouldError: false,
+ },
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ // Reset cleaning flag for each test
+ service.cleaning = false
+
+ results, err := service.Clean(tc.items)
+
+ if tc.shouldError {
+ assert.Error(t, err, "Should return error for %s", tc.name)
+ if tc.errorMsg != "" {
+ assert.Contains(t, err.Error(), tc.errorMsg, "Error message should contain: %s", tc.errorMsg)
+ }
+ assert.Nil(t, results, "Results should be nil on error")
+ }
+ })
+ }
+}
diff --git a/internal/services/scan_service.go b/internal/services/scan_service.go
index bd2f8d7..bae2062 100644
--- a/internal/services/scan_service.go
+++ b/internal/services/scan_service.go
@@ -66,7 +66,20 @@ func (s *ScanService) Scan(opts types.ScanOptions) error {
return err
}
- fmt.Printf("๐ Scan found %d results\n", len(results))
+ fmt.Printf("๐ Scan found %d results (before deduplication)\n", len(results))
+
+ // Deduplicate results by path
+ seen := make(map[string]bool)
+ dedupedResults := make([]types.ScanResult, 0, len(results))
+ for _, result := range results {
+ if !seen[result.Path] {
+ seen[result.Path] = true
+ dedupedResults = append(dedupedResults, result)
+ }
+ }
+ results = dedupedResults
+
+ fmt.Printf("๐ Scan found %d results (after deduplication)\n", len(results))
// Sort by size (largest first) using sort.Slice for O(n log n)
sort.Slice(results, func(i, j int) bool {
diff --git a/internal/services/scan_service_test.go b/internal/services/scan_service_test.go
new file mode 100644
index 0000000..9cd5e65
--- /dev/null
+++ b/internal/services/scan_service_test.go
@@ -0,0 +1,196 @@
+package services
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+ "github.com/thanhdevapp/dev-cleaner/pkg/types"
+)
+
+// TestNewScanService tests ScanService initialization
+func TestNewScanService(t *testing.T) {
+ service, err := NewScanService()
+ require.NoError(t, err, "NewScanService should not return error")
+ require.NotNil(t, service, "ScanService should not be nil")
+ assert.NotNil(t, service.scanner, "Scanner should be initialized")
+ assert.Empty(t, service.results, "Results should be empty initially")
+ assert.False(t, service.scanning, "Should not be scanning initially")
+}
+
+// TestScanDeduplication tests that duplicate paths are removed
+func TestScanDeduplication(t *testing.T) {
+ _, err := NewScanService()
+ require.NoError(t, err)
+
+ // Create mock results with duplicates
+ mockResults := []types.ScanResult{
+ {Path: "/path/to/item1", Size: 1000, Type: types.TypeNode},
+ {Path: "/path/to/item2", Size: 2000, Type: types.TypeXcode},
+ {Path: "/path/to/item1", Size: 1000, Type: types.TypeNode}, // Duplicate
+ {Path: "/path/to/item3", Size: 3000, Type: types.TypeAndroid},
+ {Path: "/path/to/item2", Size: 2000, Type: types.TypeXcode}, // Duplicate
+ }
+
+ // Simulate deduplication (same logic as in Scan method)
+ seen := make(map[string]bool)
+ dedupedResults := make([]types.ScanResult, 0, len(mockResults))
+ for _, result := range mockResults {
+ if !seen[result.Path] {
+ seen[result.Path] = true
+ dedupedResults = append(dedupedResults, result)
+ }
+ }
+
+ // Verify deduplication
+ assert.Equal(t, 3, len(dedupedResults), "Should have 3 unique items after deduplication")
+
+ // Verify no duplicates
+ paths := make(map[string]bool)
+ for _, result := range dedupedResults {
+ assert.False(t, paths[result.Path], "Path %s should not be duplicate", result.Path)
+ paths[result.Path] = true
+ }
+}
+
+// TestScanSorting tests that results are sorted by size (largest first)
+func TestScanSorting(t *testing.T) {
+ mockResults := []types.ScanResult{
+ {Path: "/small", Size: 100, Type: types.TypeNode},
+ {Path: "/large", Size: 10000, Type: types.TypeXcode},
+ {Path: "/medium", Size: 5000, Type: types.TypeAndroid},
+ {Path: "/tiny", Size: 10, Type: types.TypeReactNative},
+ }
+
+ // Sort by size (largest first) - same as scan service
+ sortBySize := func(results []types.ScanResult) {
+ for i := 0; i < len(results)-1; i++ {
+ for j := i + 1; j < len(results); j++ {
+ if results[i].Size < results[j].Size {
+ results[i], results[j] = results[j], results[i]
+ }
+ }
+ }
+ }
+
+ sortBySize(mockResults)
+
+ // Verify sorting
+ assert.Equal(t, "/large", mockResults[0].Path, "Largest item should be first")
+ assert.Equal(t, "/medium", mockResults[1].Path, "Medium item should be second")
+ assert.Equal(t, "/small", mockResults[2].Path, "Small item should be third")
+ assert.Equal(t, "/tiny", mockResults[3].Path, "Smallest item should be last")
+
+ // Verify descending order
+ for i := 0; i < len(mockResults)-1; i++ {
+ assert.GreaterOrEqual(t, mockResults[i].Size, mockResults[i+1].Size,
+ "Results should be sorted by size in descending order")
+ }
+}
+
+// TestGetResults tests GetResults method
+func TestGetResults(t *testing.T) {
+ service, err := NewScanService()
+ require.NoError(t, err)
+
+ // Initially empty
+ results := service.GetResults()
+ assert.Empty(t, results, "Results should be empty initially")
+
+ // Set some results
+ mockResults := []types.ScanResult{
+ {Path: "/test1", Size: 1000, Type: types.TypeNode},
+ {Path: "/test2", Size: 2000, Type: types.TypeXcode},
+ }
+ service.results = mockResults
+
+ // Get results
+ results = service.GetResults()
+ assert.Equal(t, 2, len(results), "Should return 2 results")
+ assert.Equal(t, mockResults, results, "Should return exact results")
+}
+
+// TestIsScanning tests IsScanning method
+func TestIsScanning(t *testing.T) {
+ service, err := NewScanService()
+ require.NoError(t, err)
+
+ // Initially not scanning
+ assert.False(t, service.IsScanning(), "Should not be scanning initially")
+
+ // Set scanning flag
+ service.scanning = true
+ assert.True(t, service.IsScanning(), "Should be scanning after flag set")
+
+ // Unset scanning flag
+ service.scanning = false
+ assert.False(t, service.IsScanning(), "Should not be scanning after flag unset")
+}
+
+// TestConcurrentScan tests that concurrent scans are prevented
+func TestConcurrentScan(t *testing.T) {
+ service, err := NewScanService()
+ require.NoError(t, err)
+
+ // Set scanning flag to simulate ongoing scan
+ service.mu.Lock()
+ service.scanning = true
+ service.mu.Unlock()
+
+ // Try to scan while already scanning
+ opts := types.ScanOptions{
+ IncludeNode: true,
+ IncludeXcode: true,
+ IncludeAndroid: true,
+ MaxDepth: 3,
+ }
+
+ err = service.Scan(opts)
+ assert.Error(t, err, "Should return error when scan already in progress")
+ assert.Contains(t, err.Error(), "scan already in progress", "Error message should indicate scan in progress")
+}
+
+// TestDeduplicationPreservesFirst tests that deduplication keeps first occurrence
+func TestDeduplicationPreservesFirst(t *testing.T) {
+ mockResults := []types.ScanResult{
+ {Path: "/path/to/item", Size: 1000, Type: types.TypeNode, Name: "First"},
+ {Path: "/path/to/item", Size: 2000, Type: types.TypeXcode, Name: "Second"}, // Duplicate - different metadata
+ }
+
+ // Deduplicate
+ seen := make(map[string]bool)
+ dedupedResults := make([]types.ScanResult, 0)
+ for _, result := range mockResults {
+ if !seen[result.Path] {
+ seen[result.Path] = true
+ dedupedResults = append(dedupedResults, result)
+ }
+ }
+
+ // Verify only first occurrence is kept
+ assert.Equal(t, 1, len(dedupedResults), "Should have only 1 item after deduplication")
+ assert.Equal(t, "First", dedupedResults[0].Name, "Should keep first occurrence")
+ assert.Equal(t, int64(1000), dedupedResults[0].Size, "Should preserve first occurrence's size")
+ assert.Equal(t, types.TypeNode, dedupedResults[0].Type, "Should preserve first occurrence's type")
+}
+
+// TestEmptyResults tests handling of empty scan results
+func TestEmptyResults(t *testing.T) {
+ _, err := NewScanService()
+ require.NoError(t, err)
+
+ // Empty results
+ var emptyResults []types.ScanResult
+
+ // Deduplicate empty results
+ seen := make(map[string]bool)
+ dedupedResults := make([]types.ScanResult, 0)
+ for _, result := range emptyResults {
+ if !seen[result.Path] {
+ seen[result.Path] = true
+ dedupedResults = append(dedupedResults, result)
+ }
+ }
+
+ assert.Empty(t, dedupedResults, "Empty results should remain empty after deduplication")
+}
diff --git a/internal/services/settings_service.go b/internal/services/settings_service.go
index 78ecce6..82892d4 100644
--- a/internal/services/settings_service.go
+++ b/internal/services/settings_service.go
@@ -14,6 +14,7 @@ type Settings struct {
ConfirmDelete bool `json:"confirmDelete"` // Show confirm dialog
ScanCategories []string `json:"scanCategories"` // ["xcode", "android", "node"]
MaxDepth int `json:"maxDepth"` // Tree depth limit
+ CheckAutoUpdate bool `json:"checkAutoUpdate"` // Check for updates on startup
}
type SettingsService struct {
@@ -41,12 +42,13 @@ func (s *SettingsService) Load() error {
if err != nil {
// Set defaults
s.settings = Settings{
- Theme: "auto",
- DefaultView: "split",
- AutoScan: true,
- ConfirmDelete: true,
- ScanCategories: []string{"xcode", "android", "node"},
- MaxDepth: 5,
+ Theme: "auto",
+ DefaultView: "split",
+ AutoScan: true,
+ ConfirmDelete: true,
+ ScanCategories: []string{"xcode", "android", "node"},
+ MaxDepth: 5,
+ CheckAutoUpdate: true,
}
return nil
}
diff --git a/internal/services/settings_service_test.go b/internal/services/settings_service_test.go
new file mode 100644
index 0000000..c80c7d1
--- /dev/null
+++ b/internal/services/settings_service_test.go
@@ -0,0 +1,191 @@
+package services
+
+import (
+ "encoding/json"
+ "os"
+ "path/filepath"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+// TestNewSettingsService tests SettingsService initialization
+func TestNewSettingsService(t *testing.T) {
+ service := NewSettingsService()
+ require.NotNil(t, service, "SettingsService should not be nil")
+ assert.NotEmpty(t, service.path, "Path should be set")
+
+ // Note: Cannot test exact default values because settings file may already exist
+ // Just verify service is properly initialized
+ settings := service.Get()
+ assert.NotEmpty(t, settings.Theme, "Theme should not be empty")
+ assert.NotEmpty(t, settings.DefaultView, "DefaultView should not be empty")
+}
+
+// TestSettingsGet tests Get method
+func TestSettingsGet(t *testing.T) {
+ service := NewSettingsService()
+
+ settings := service.Get()
+ assert.NotNil(t, settings, "Settings should not be nil")
+
+ // Verify it's a copy (not a reference)
+ settings.Theme = "modified"
+ originalSettings := service.Get()
+ assert.NotEqual(t, settings.Theme, originalSettings.Theme,
+ "Modifying returned settings should not affect internal settings")
+}
+
+// TestSettingsUpdate tests Update method
+func TestSettingsUpdate(t *testing.T) {
+ // Create temporary directory for test
+ tmpDir := t.TempDir()
+ service := &SettingsService{
+ path: filepath.Join(tmpDir, "test-settings.json"),
+ }
+ service.Load()
+
+ // Update settings
+ newSettings := Settings{
+ Theme: "dark",
+ DefaultView: "list",
+ AutoScan: false,
+ ConfirmDelete: false,
+ ScanCategories: []string{"node", "react-native"},
+ MaxDepth: 3,
+ CheckAutoUpdate: false,
+ }
+
+ err := service.Update(newSettings)
+ require.NoError(t, err, "Update should not return error")
+
+ // Verify settings were updated
+ currentSettings := service.Get()
+ assert.Equal(t, "dark", currentSettings.Theme)
+ assert.Equal(t, "list", currentSettings.DefaultView)
+ assert.False(t, currentSettings.AutoScan)
+ assert.False(t, currentSettings.ConfirmDelete)
+ assert.False(t, currentSettings.CheckAutoUpdate)
+ assert.Equal(t, 3, currentSettings.MaxDepth)
+ assert.Equal(t, []string{"node", "react-native"}, currentSettings.ScanCategories)
+}
+
+// TestSettingsSaveAndLoad tests Save and Load methods
+func TestSettingsSaveAndLoad(t *testing.T) {
+ // Create temporary directory for test
+ tmpDir := t.TempDir()
+ settingsPath := filepath.Join(tmpDir, "test-settings.json")
+
+ // Create service and set custom settings
+ service1 := &SettingsService{
+ path: settingsPath,
+ settings: Settings{
+ Theme: "light",
+ DefaultView: "treemap",
+ AutoScan: true,
+ ConfirmDelete: false,
+ ScanCategories: []string{"flutter", "python"},
+ MaxDepth: 10,
+ CheckAutoUpdate: true,
+ },
+ }
+
+ // Save settings
+ err := service1.Save()
+ require.NoError(t, err, "Save should not return error")
+
+ // Verify file was created
+ _, err = os.Stat(settingsPath)
+ assert.NoError(t, err, "Settings file should exist")
+
+ // Create new service and load settings
+ service2 := &SettingsService{
+ path: settingsPath,
+ }
+ err = service2.Load()
+ require.NoError(t, err, "Load should not return error")
+
+ // Verify loaded settings match saved settings
+ loadedSettings := service2.Get()
+ assert.Equal(t, "light", loadedSettings.Theme)
+ assert.Equal(t, "treemap", loadedSettings.DefaultView)
+ assert.True(t, loadedSettings.AutoScan)
+ assert.False(t, loadedSettings.ConfirmDelete)
+ assert.True(t, loadedSettings.CheckAutoUpdate)
+ assert.Equal(t, 10, loadedSettings.MaxDepth)
+ assert.Equal(t, []string{"flutter", "python"}, loadedSettings.ScanCategories)
+}
+
+// TestSettingsLoadNonExistentFile tests loading when file doesn't exist
+func TestSettingsLoadNonExistentFile(t *testing.T) {
+ // Create temporary directory for test
+ tmpDir := t.TempDir()
+ service := &SettingsService{
+ path: filepath.Join(tmpDir, "non-existent.json"),
+ }
+
+ // Load should not error and should use defaults
+ err := service.Load()
+ assert.NoError(t, err, "Load should not error for non-existent file")
+
+ // Verify default settings
+ settings := service.Get()
+ assert.Equal(t, "auto", settings.Theme, "Should use default theme")
+ assert.Equal(t, "split", settings.DefaultView, "Should use default view")
+ assert.True(t, settings.AutoScan, "Should use default AutoScan")
+ assert.True(t, settings.ConfirmDelete, "Should use default ConfirmDelete")
+ assert.True(t, settings.CheckAutoUpdate, "Should use default CheckAutoUpdate")
+}
+
+// TestSettingsJSONMarshaling tests JSON marshaling/unmarshaling
+func TestSettingsJSONMarshaling(t *testing.T) {
+ originalSettings := Settings{
+ Theme: "dark",
+ DefaultView: "list",
+ AutoScan: false,
+ ConfirmDelete: true,
+ ScanCategories: []string{"xcode", "android"},
+ MaxDepth: 7,
+ CheckAutoUpdate: false,
+ }
+
+ // Marshal to JSON
+ data, err := json.Marshal(originalSettings)
+ require.NoError(t, err, "JSON marshal should not error")
+
+ // Unmarshal from JSON
+ var loadedSettings Settings
+ err = json.Unmarshal(data, &loadedSettings)
+ require.NoError(t, err, "JSON unmarshal should not error")
+
+ // Verify all fields match
+ assert.Equal(t, originalSettings.Theme, loadedSettings.Theme)
+ assert.Equal(t, originalSettings.DefaultView, loadedSettings.DefaultView)
+ assert.Equal(t, originalSettings.AutoScan, loadedSettings.AutoScan)
+ assert.Equal(t, originalSettings.ConfirmDelete, loadedSettings.ConfirmDelete)
+ assert.Equal(t, originalSettings.CheckAutoUpdate, loadedSettings.CheckAutoUpdate)
+ assert.Equal(t, originalSettings.MaxDepth, loadedSettings.MaxDepth)
+ assert.Equal(t, originalSettings.ScanCategories, loadedSettings.ScanCategories)
+}
+
+// TestSettingsConcurrentAccess tests concurrent read/write access
+func TestSettingsConcurrentAccess(t *testing.T) {
+ service := NewSettingsService()
+
+ // Concurrent reads should not panic
+ done := make(chan bool, 10)
+ for i := 0; i < 10; i++ {
+ go func() {
+ _ = service.Get()
+ done <- true
+ }()
+ }
+
+ // Wait for all reads to complete
+ for i := 0; i < 10; i++ {
+ <-done
+ }
+
+ assert.True(t, true, "Concurrent reads should complete without panic")
+}
diff --git a/internal/services/update_service.go b/internal/services/update_service.go
new file mode 100644
index 0000000..a4f1dcd
--- /dev/null
+++ b/internal/services/update_service.go
@@ -0,0 +1,163 @@
+package services
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+ "strings"
+ "sync"
+ "time"
+)
+
+// GitHubRelease represents a GitHub release response
+type GitHubRelease struct {
+ TagName string `json:"tag_name"`
+ Name string `json:"name"`
+ Draft bool `json:"draft"`
+ Prerelease bool `json:"prerelease"`
+ PublishedAt time.Time `json:"published_at"`
+ HTMLURL string `json:"html_url"`
+ Body string `json:"body"`
+}
+
+// UpdateInfo contains version update information
+type UpdateInfo struct {
+ Available bool `json:"available"`
+ CurrentVersion string `json:"currentVersion"`
+ LatestVersion string `json:"latestVersion"`
+ ReleaseURL string `json:"releaseURL"`
+ ReleaseNotes string `json:"releaseNotes"`
+ PublishedAt time.Time `json:"publishedAt"`
+}
+
+type UpdateService struct {
+ ctx context.Context
+ currentVersion string
+ repoOwner string
+ repoName string
+ lastCheck time.Time
+ lastResult *UpdateInfo
+ mu sync.RWMutex
+}
+
+func NewUpdateService(currentVersion, repoOwner, repoName string) *UpdateService {
+ return &UpdateService{
+ currentVersion: currentVersion,
+ repoOwner: repoOwner,
+ repoName: repoName,
+ }
+}
+
+func (s *UpdateService) SetContext(ctx context.Context) {
+ s.ctx = ctx
+}
+
+// CheckForUpdates checks GitHub API for latest release
+func (s *UpdateService) CheckForUpdates() (*UpdateInfo, error) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+
+ // Cache check results for 5 minutes to avoid rate limiting
+ if time.Since(s.lastCheck) < 5*time.Minute && s.lastResult != nil {
+ return s.lastResult, nil
+ }
+
+ url := fmt.Sprintf("https://api.github.com/repos/%s/%s/releases/latest", s.repoOwner, s.repoName)
+
+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+ defer cancel()
+
+ req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
+ if err != nil {
+ return nil, fmt.Errorf("failed to create request: %w", err)
+ }
+
+ req.Header.Set("Accept", "application/vnd.github.v3+json")
+ req.Header.Set("User-Agent", "Mac-Dev-Cleaner")
+
+ client := &http.Client{Timeout: 10 * time.Second}
+ resp, err := client.Do(req)
+ if err != nil {
+ return nil, fmt.Errorf("failed to fetch release info: %w", err)
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode != http.StatusOK {
+ body, _ := io.ReadAll(resp.Body)
+ return nil, fmt.Errorf("GitHub API error (%d): %s", resp.StatusCode, string(body))
+ }
+
+ var release GitHubRelease
+ if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {
+ return nil, fmt.Errorf("failed to decode response: %w", err)
+ }
+
+ // Skip draft and prerelease versions
+ if release.Draft || release.Prerelease {
+ info := &UpdateInfo{
+ Available: false,
+ CurrentVersion: s.currentVersion,
+ LatestVersion: s.currentVersion,
+ }
+ s.lastCheck = time.Now()
+ s.lastResult = info
+ return info, nil
+ }
+
+ latestVersion := strings.TrimPrefix(release.TagName, "v")
+ currentVersion := strings.TrimPrefix(s.currentVersion, "v")
+
+ isNewer := compareVersions(latestVersion, currentVersion)
+
+ info := &UpdateInfo{
+ Available: isNewer,
+ CurrentVersion: s.currentVersion,
+ LatestVersion: release.TagName,
+ ReleaseURL: release.HTMLURL,
+ ReleaseNotes: release.Body,
+ PublishedAt: release.PublishedAt,
+ }
+
+ s.lastCheck = time.Now()
+ s.lastResult = info
+
+ return info, nil
+}
+
+// compareVersions compares two semantic versions (without 'v' prefix)
+// Returns true if v1 > v2
+func compareVersions(v1, v2 string) bool {
+ // Simple semantic version comparison
+ // Format: major.minor.patch
+ parts1 := strings.Split(v1, ".")
+ parts2 := strings.Split(v2, ".")
+
+ for i := 0; i < 3; i++ {
+ var n1, n2 int
+ if i < len(parts1) {
+ fmt.Sscanf(parts1[i], "%d", &n1)
+ }
+ if i < len(parts2) {
+ fmt.Sscanf(parts2[i], "%d", &n2)
+ }
+
+ if n1 > n2 {
+ return true
+ }
+ if n1 < n2 {
+ return false
+ }
+ }
+
+ return false
+}
+
+// ClearCache clears the cached result
+func (s *UpdateService) ClearCache() {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ s.lastResult = nil
+ s.lastCheck = time.Time{}
+}
diff --git a/internal/tui/tui.go b/internal/tui/tui.go
index 68e930b..332b37d 100644
--- a/internal/tui/tui.go
+++ b/internal/tui/tui.go
@@ -10,6 +10,7 @@ import (
"github.com/charmbracelet/bubbles/key"
"github.com/charmbracelet/bubbles/progress"
"github.com/charmbracelet/bubbles/spinner"
+ "github.com/charmbracelet/bubbles/table"
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
"github.com/thanhdevapp/dev-cleaner/internal/cleaner"
@@ -40,13 +41,14 @@ type treeState struct {
// Tips array - shown randomly to help users
var tips = []string{
- "๐ก Tip: Press 'c' to quickly clean the current item without selecting it first",
+ "๐ก Tip: Press 'c' to quickly clean ONLY the current item (clears other selections)",
+ "๐ก Tip: Select multiple items with Space, then press Enter to clean them all at once",
"๐ก Tip: Use 'a' to select all items, 'n' to deselect all",
"๐ก Tip: Press 'โ' or 'l' to drill down into folders and explore their contents",
"๐ก Tip: In tree mode, press 'โ' or 'h' to go back to parent folder",
"๐ก Tip: Dry-run mode is active by default - your files are safe until you confirm",
"๐ก Tip: Press '?' anytime to see detailed help and keyboard shortcuts",
- "๐ก Tip: Use Space to toggle individual items, Enter to clean all selected",
+ "๐ก Tip: 'c' = quick single clean, Enter = batch clean selected items",
"๐ก Tip: In tree mode, 'c' lets you delete folders at any level",
"๐ก Tip: All deletion operations are logged to ~/.dev-cleaner.log",
"๐ก Tip: Press 'Esc' in tree mode to return to main list",
@@ -104,10 +106,10 @@ var (
Bold(true)
statusCenterStyle = lipgloss.NewStyle().
- Foreground(lipgloss.Color("#F59E0B"))
+ Foreground(lipgloss.Color("#F59E0B"))
statusRightStyle = lipgloss.NewStyle().
- Foreground(lipgloss.Color("#6B7280"))
+ Foreground(lipgloss.Color("#6B7280"))
)
// KeyMap defines the key bindings
@@ -215,23 +217,131 @@ type Model struct {
savedTreeState *treeState // Saved tree state for restoration
// Time tracking
- startTime time.Time // Session start time
- deleteStart time.Time // Delete operation start time
+ startTime time.Time // Session start time
+ deleteStart time.Time // Delete operation start time
+ deleteDuration time.Duration // Frozen duration when deletion completes
// Scanning progress
- scanningCategories []string // Categories being scanned
+ scanningCategories []string // Categories being scanned
scanComplete map[string]bool // Which categories are complete
- currentScanning int // Index of currently scanning category
+ currentScanning int // Index of currently scanning category
// Deletion progress
- deletingItems []types.ScanResult // Items being deleted
- deleteComplete map[int]bool // Which items are complete
- deleteStatus map[int]string // Status for each item (success/error)
- currentDeleting int // Index of currently deleting item
+ deletingItems []types.ScanResult // Items being deleted
+ deleteComplete map[int]bool // Which items are complete
+ deleteStatus map[int]string // Status for each item (success/error)
+ currentDeleting int // Index of currently deleting item
+ fakeProgress float64 // Fake progress for smooth animation
// Help and tips
currentTip string // Current random tip to display
showHelp bool // Whether to show help screen
+
+ // Table view
+ itemsTable table.Model // Table for rendering items list
+ treeTable table.Model // Table for rendering tree view
+}
+
+// updateTableRows updates the table rows to reflect current selections
+func (m *Model) updateTableRows() {
+ rows := []table.Row{}
+ for i, item := range m.items {
+ checkbox := "[ ]"
+ if m.selected[i] {
+ checkbox = "[โ]"
+ }
+
+ typeBadge := string(item.Type)
+ sizeStr := ui.FormatSize(item.Size)
+
+ rows = append(rows, table.Row{
+ checkbox,
+ typeBadge,
+ sizeStr,
+ item.Name,
+ item.Path, // Full path
+ })
+ }
+ m.itemsTable.SetRows(rows)
+ m.itemsTable.SetCursor(m.cursor)
+}
+
+// updateTreeTableRows updates the tree table rows to reflect current selections
+func (m *Model) updateTreeTableRows() {
+ if m.currentNode == nil || !m.currentNode.HasChildren() {
+ m.treeTable.SetRows([]table.Row{})
+ return
+ }
+
+ rows := []table.Row{}
+ for _, child := range m.currentNode.Children {
+ checkbox := "[ ]"
+ if m.treeSelected[child.Path] {
+ checkbox = "[โ]"
+ }
+
+ // Icon based on type
+ icon := "๐"
+ if child.IsDir {
+ if child.Scanned {
+ icon = "๐"
+ } else {
+ icon = "๐"
+ }
+ }
+
+ sizeStr := ui.FormatSize(child.Size)
+
+ rows = append(rows, table.Row{
+ checkbox,
+ icon,
+ sizeStr,
+ child.Name,
+ child.Path, // Full path
+ })
+ }
+ m.treeTable.SetRows(rows)
+ m.treeTable.SetCursor(m.cursor)
+}
+
+// updateTableColumns updates table column widths based on terminal width
+func (m *Model) updateTableColumns() {
+ if m.width == 0 {
+ return // No width info yet
+ }
+
+ // Fixed column widths: checkbox(3) + category/type(12 or 4) + size(10) + name(30) + borders/padding(~10)
+ fixedWidth := 3 + 12 + 10 + 30 + 10
+ pathWidth := m.width - fixedWidth
+ if pathWidth < 30 {
+ pathWidth = 30 // Minimum path width
+ }
+
+ // Update main table columns
+ mainCols := []table.Column{
+ {Title: "", Width: 3}, // Checkbox
+ {Title: "Category", Width: 12}, // Type badge
+ {Title: "Size", Width: 10}, // Formatted size
+ {Title: "Name", Width: 30}, // Item name
+ {Title: "Path", Width: pathWidth}, // Dynamic path width
+ }
+ m.itemsTable.SetColumns(mainCols)
+
+ // Update tree table columns (slightly different fixed widths)
+ treeFixedWidth := 3 + 4 + 10 + 30 + 10
+ treePathWidth := m.width - treeFixedWidth
+ if treePathWidth < 30 {
+ treePathWidth = 30
+ }
+
+ treeCols := []table.Column{
+ {Title: "", Width: 3}, // Checkbox
+ {Title: "Type", Width: 4}, // Icon
+ {Title: "Size", Width: 10}, // Formatted size
+ {Title: "Name", Width: 30}, // Item name
+ {Title: "Path", Width: treePathWidth}, // Dynamic path width
+ }
+ m.treeTable.SetColumns(treeCols)
}
// NewModel creates a new TUI model
@@ -291,14 +401,84 @@ func NewModel(items []types.ScanResult, dryRun bool, version string) Model {
// Pick a random tip
randomTip := tips[time.Now().UnixNano()%int64(len(tips))]
- return Model{
- state: initialState,
- items: items,
- selected: make(map[int]bool),
- dryRun: dryRun,
- version: version,
- spinner: s,
- progress: p,
+ // Create table columns
+ columns := []table.Column{
+ {Title: "", Width: 3}, // Checkbox
+ {Title: "Category", Width: 12}, // Type badge
+ {Title: "Size", Width: 10}, // Formatted size
+ {Title: "Name", Width: 30}, // Item name (shorter to make room for path)
+ {Title: "Path", Width: 50}, // Full path
+ }
+
+ // Create table rows from items
+ rows := []table.Row{}
+ for _, item := range items {
+ checkbox := "[ ]"
+ typeBadge := string(item.Type)
+ sizeStr := ui.FormatSize(item.Size)
+
+ rows = append(rows, table.Row{
+ checkbox,
+ typeBadge,
+ sizeStr,
+ item.Name,
+ item.Path, // Full path
+ })
+ }
+
+ // Initialize table with dynamic height to show all items
+ tableHeight := len(items)
+ if tableHeight < 5 {
+ tableHeight = 5 // Minimum height
+ }
+ if tableHeight > 30 {
+ tableHeight = 30 // Cap at 30 to prevent huge tables
+ }
+ t := table.New(
+ table.WithColumns(columns),
+ table.WithRows(rows),
+ table.WithFocused(true),
+ table.WithHeight(tableHeight),
+ )
+
+ // Apply table styles
+ ts := table.DefaultStyles()
+ ts.Header = ts.Header.
+ BorderStyle(lipgloss.NormalBorder()).
+ BorderForeground(lipgloss.Color("#7C3AED")).
+ BorderBottom(true).
+ Bold(false)
+ ts.Selected = ts.Selected.
+ Foreground(lipgloss.Color("#FFFFFF")).
+ Background(lipgloss.Color("#7C3AED")).
+ Bold(false)
+ t.SetStyles(ts)
+
+ // Create tree table (same columns as main table but with icon instead of type)
+ treeColumns := []table.Column{
+ {Title: "", Width: 3}, // Checkbox
+ {Title: "Type", Width: 4}, // Icon (๐/๐/๐)
+ {Title: "Size", Width: 10}, // Formatted size
+ {Title: "Name", Width: 30}, // Item name (shorter to make room for path)
+ {Title: "Path", Width: 50}, // Full path
+ }
+
+ treeT := table.New(
+ table.WithColumns(treeColumns),
+ table.WithRows([]table.Row{}),
+ table.WithFocused(true),
+ table.WithHeight(20), // Tree view can be taller
+ )
+ treeT.SetStyles(ts)
+
+ m := Model{
+ state: initialState,
+ items: items,
+ selected: make(map[int]bool),
+ dryRun: dryRun,
+ version: version,
+ spinner: s,
+ progress: p,
// Tree navigation
treeMode: false,
nodeStack: make([]*types.TreeNode, 0),
@@ -319,7 +499,15 @@ func NewModel(items []types.ScanResult, dryRun bool, version string) Model {
// Help and tips
currentTip: randomTip,
showHelp: false,
+ // Table view
+ itemsTable: t,
+ treeTable: treeT,
}
+
+ // Initialize table rows
+ m.updateTableRows()
+
+ return m
}
// Init implements tea.Model
@@ -337,6 +525,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
m.width = msg.Width
m.height = msg.Height
m.progress.Width = msg.Width - 10
+ m.updateTableColumns() // Update table columns to fit new width
return m, nil
case spinner.TickMsg:
@@ -349,6 +538,32 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
m.progress = progressModel.(progress.Model)
return m, cmd
+ case deletionTickMsg:
+ // Keep UI responsive during deletion - tick spinner, update progress, and schedule next tick
+ if m.state == StateDeleting {
+ var spinnerCmd tea.Cmd
+ m.spinner, spinnerCmd = m.spinner.Update(m.spinner.Tick())
+
+ // Increment fake progress for smooth animation (small increments until real progress catches up)
+ targetProgress := float64(m.currentDeleting) / float64(len(m.deletingItems))
+ if m.fakeProgress < targetProgress {
+ m.fakeProgress = targetProgress // Snap to real progress
+ } else if m.fakeProgress < 0.99 && m.fakeProgress < targetProgress+0.05 {
+ // Small fake increment to show activity
+ m.fakeProgress += 0.002
+ }
+
+ // Update progress bar with combined progress
+ displayProgress := m.fakeProgress
+ if m.percent > displayProgress {
+ displayProgress = m.percent
+ }
+ progressCmd := m.progress.SetPercent(displayProgress)
+
+ return m, tea.Batch(spinnerCmd, progressCmd, m.tickDeletion())
+ }
+ return m, nil
+
case deleteProgressMsg:
m.percent = msg.percent
cmd := m.progress.SetPercent(m.percent)
@@ -358,30 +573,62 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
// Handle based on current state
switch m.state {
case StateDone:
- // 'q' to quit, any other key to rescan/return to tree
- if msg.String() == "q" || msg.String() == "ctrl+c" {
+ switch msg.String() {
+ case "q", "ctrl+c":
+ // Quit application
m.quitting = true
return m, tea.Quit
- }
- // Check if we should return to tree mode
- if m.returnToTree && m.savedTreeState != nil {
- // Restore tree state
- m.state = StateTree
- m.treeMode = true
- m.currentNode = m.savedTreeState.parentNode
- m.nodeStack = m.savedTreeState.nodeStack
- m.cursor = 0 // Reset cursor to top
+ case "r", "enter":
+ // Rescan and refresh results - return to view immediately for better UX
+ // Check if we should return to tree mode
+ if m.returnToTree && m.savedTreeState != nil {
+ // Restore tree state immediately
+ m.state = StateTree
+ m.treeMode = true
+ m.currentNode = m.savedTreeState.parentNode
+ m.nodeStack = m.savedTreeState.nodeStack
+ m.cursor = 0 // Reset cursor to top
+ m.scanning = true
+ m.returnToTree = false
+ m.savedTreeState = nil
+ m.updateTreeTableRows()
+
+ // Trigger rescan in background (non-blocking)
+ return m, m.rescanNode(m.currentNode)
+ }
+
+ // Normal rescan - transition to selecting state immediately
+ m.state = StateSelecting
+ m.results = nil
+ m.err = nil
m.scanning = true
- m.returnToTree = false
- m.savedTreeState = nil
+ m.updateTableRows()
- // Rescan current node to refresh after deletion
- return m, m.rescanNode(m.currentNode)
- }
+ // Trigger rescan in background (non-blocking)
+ return m, m.rescanItems()
+
+ case "esc":
+ // Go back to selection without rescanning
+ if m.returnToTree && m.savedTreeState != nil {
+ // Restore tree state without rescanning
+ m.state = StateTree
+ m.treeMode = true
+ m.currentNode = m.savedTreeState.parentNode
+ m.nodeStack = m.savedTreeState.nodeStack
+ m.cursor = m.savedTreeState.cursorPos
+ m.returnToTree = false
+ m.savedTreeState = nil
+ m.updateTreeTableRows()
+ return m, nil
+ }
- // Normal rescan and return to selection
- return m, m.rescanItems()
+ // Go back to main list without rescanning
+ m.state = StateSelecting
+ m.results = nil
+ m.err = nil
+ return m, nil
+ }
case StateConfirming:
switch msg.String() {
@@ -401,13 +648,11 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
m.deleteStatus = make(map[int]string)
m.currentDeleting = 0
- // Debug: Print to stderr
- fmt.Fprintf(os.Stderr, "[DEBUG] Starting deletion of %d items\n", len(m.deletingItems))
-
- // Start deletion with spinner and progress updates
+ // Start deletion with spinner, progress updates, and continuous tick
return m, tea.Batch(
m.spinner.Tick,
m.progress.SetPercent(0),
+ m.tickDeletion(), // Start continuous UI refresh
m.performClean(),
)
case "n", "N", "esc":
@@ -455,23 +700,28 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
case key.Matches(msg, keys.Up):
if m.cursor > 0 {
m.cursor--
+ m.updateTableRows()
}
case key.Matches(msg, keys.Down):
if m.cursor < len(m.items)-1 {
m.cursor++
+ m.updateTableRows()
}
case key.Matches(msg, keys.Toggle):
m.selected[m.cursor] = !m.selected[m.cursor]
+ m.updateTableRows()
case key.Matches(msg, keys.All):
for i := range m.items {
m.selected[i] = true
}
+ m.updateTableRows()
case key.Matches(msg, keys.None):
m.selected = make(map[int]bool)
+ m.updateTableRows()
case key.Matches(msg, keys.Confirm):
if m.countSelected() > 0 {
@@ -517,6 +767,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
case key.Matches(msg, keys.GoBack):
m.goBackInTree()
+ m.updateTreeTableRows()
return m, nil
case key.Matches(msg, keys.DrillDown):
@@ -532,12 +783,14 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
case key.Matches(msg, keys.Up):
if m.cursor > 0 {
m.cursor--
+ m.updateTreeTableRows()
}
case key.Matches(msg, keys.Down):
if m.currentNode != nil && m.currentNode.HasChildren() {
if m.cursor < len(m.currentNode.Children)-1 {
m.cursor++
+ m.updateTreeTableRows()
}
}
@@ -546,6 +799,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
if m.cursor < len(m.currentNode.Children) {
child := m.currentNode.Children[m.cursor]
m.treeSelected[child.Path] = !m.treeSelected[child.Path]
+ m.updateTreeTableRows()
}
}
@@ -586,9 +840,6 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
}
case deleteItemProgressMsg:
- // Debug
- fmt.Fprintf(os.Stderr, "[DEBUG] Item %d completed with status: %s\n", msg.index, msg.status)
-
// Update item status
m.deleteComplete[msg.index] = true
if msg.status == "error" {
@@ -603,19 +854,20 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
m.percent = float64(m.currentDeleting) / float64(len(m.deletingItems))
}
- fmt.Fprintf(os.Stderr, "[DEBUG] Progress: %d/%d (%.0f%%)\n", m.currentDeleting, len(m.deletingItems), m.percent*100)
-
// Continue with next item or finish
return m, tea.Batch(
- m.spinner.Tick, // Keep spinner animating
+ m.spinner.Tick, // Keep spinner animating
m.progress.SetPercent(m.percent),
- m.performClean(), // Delete next item or finish
+ m.performClean(), // Delete next item or finish
)
case cleanResultMsg:
m.state = StateDone
m.results = msg.results
m.err = msg.err
+ // Freeze the deletion duration so timer stops counting
+ m.deleteDuration = time.Since(m.deleteStart)
+ m.percent = 1.0 // Ensure progress shows 100%
return m, nil
case scanNodeMsg:
@@ -629,11 +881,13 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
m.nodeStack = make([]*types.TreeNode, 0)
}
m.cursor = 0
+ m.updateTreeTableRows()
return m, nil
case rescanItemsMsg:
if msg.err != nil {
m.err = msg.err
+ m.scanning = false
return m, nil
}
// Reset state and show new items
@@ -643,6 +897,8 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
m.state = StateSelecting
m.results = nil
m.err = nil
+ m.scanning = false
+ m.updateTableRows()
return m, nil
case scanProgressMsg:
@@ -659,6 +915,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
// If all categories scanned, transition to selecting
if m.currentScanning >= len(m.scanningCategories) {
m.state = StateSelecting
+ m.updateTableRows()
return m, nil
}
@@ -697,9 +954,19 @@ type scanProgressMsg struct{}
// deleteItemProgressMsg is sent when an item deletion starts/completes
type deleteItemProgressMsg struct {
- index int
- status string // "start", "success", "error"
- err error
+ index int
+ status string // "start", "success", "error"
+ err error
+}
+
+// deletionTickMsg for UI refresh during deletion
+type deletionTickMsg struct{}
+
+// tickDeletion sends periodic UI refresh messages during deletion
+func (m Model) tickDeletion() tea.Cmd {
+ return tea.Tick(time.Millisecond*100, func(t time.Time) tea.Msg {
+ return deletionTickMsg{}
+ })
}
// tickScanning sends a message to advance scanning animation
@@ -823,6 +1090,7 @@ func (m *Model) drillDownInTree() tea.Cmd {
m.nodeStack = append(m.nodeStack, m.currentNode)
m.currentNode = selectedNode
m.cursor = 0
+ m.updateTreeTableRows()
return nil
}
@@ -919,7 +1187,6 @@ func (m Model) findNodeByPath(root *types.TreeNode, path string) *types.TreeNode
func (m Model) performClean() tea.Cmd {
// Check if all items are processed
if m.currentDeleting >= len(m.deletingItems) {
- fmt.Fprintf(os.Stderr, "[DEBUG] All items processed, finishing...\n")
// All done, collect results and finish
var results []cleaner.CleanResult
for i, item := range m.deletingItems {
@@ -945,8 +1212,6 @@ func (m Model) performClean() tea.Cmd {
idx := m.currentDeleting
item := m.deletingItems[idx]
- fmt.Fprintf(os.Stderr, "[DEBUG] Starting deletion of item %d: %s\n", idx, item.Name)
-
return func() tea.Msg {
c, err := cleaner.New(m.dryRun)
if err != nil {
@@ -1120,43 +1385,13 @@ func (m Model) renderTreeView(b *strings.Builder) string {
b.WriteString(" Scanning folder...\n\n")
}
- // Children list
+ // Children list - use table
if !m.currentNode.HasChildren() {
b.WriteString(helpStyle.Render(" (Empty folder)"))
} else {
- for i, child := range m.currentNode.Children {
- cursor := " "
- if i == m.cursor {
- cursor = cursorStyle.Render("โธ ")
- }
-
- checkbox := "[ ]"
- if m.treeSelected[child.Path] {
- checkbox = checkboxStyle.Render("[โ]")
- }
-
- // Icon based on type and scan status
- icon := m.getTreeIcon(child)
-
- // Size with color
- sizeStr := ui.FormatSize(child.Size)
- sizeStyle := m.getSizeStyle(child.Size)
-
- line := fmt.Sprintf("%s%s %s %s %s",
- cursor,
- checkbox,
- icon,
- sizeStyle.Render(fmt.Sprintf("%10s", sizeStr)),
- child.Name,
- )
-
- if i == m.cursor {
- b.WriteString(selectedItemStyle.Render(line))
- } else {
- b.WriteString(itemStyle.Render(line))
- }
- b.WriteString("\n")
- }
+ // Render tree table (already updated in Update())
+ b.WriteString(m.treeTable.View())
+ b.WriteString("\n")
}
// Depth info
@@ -1306,78 +1541,101 @@ func (m Model) renderDeleting(b *strings.Builder) string {
// renderConfirmation shows the confirmation dialog
func (m Model) renderConfirmation(b *strings.Builder) string {
- selectedCount := m.countSelected()
- selectedSize := m.selectedSize()
+ // Calculate count and size based on source
+ var selectedCount int
+ var selectedSize int64
+
+ // Check if coming from tree mode (has deletingItems)
+ if len(m.deletingItems) > 0 {
+ // Tree mode - calculate from deletingItems
+ selectedCount = len(m.deletingItems)
+ for _, item := range m.deletingItems {
+ selectedSize += item.Size
+ }
+ } else {
+ // Normal selection mode
+ selectedCount = m.countSelected()
+ selectedSize = m.selectedSize()
+ }
- // Confirmation box style
+ // Confirmation box style - wider to show paths
confirmBoxStyle := lipgloss.NewStyle().
Border(lipgloss.RoundedBorder()).
BorderForeground(lipgloss.Color("#F59E0B")).
Padding(1, 2).
- Width(50)
+ Width(80)
warningStyle := lipgloss.NewStyle().
Foreground(lipgloss.Color("#F59E0B")).
Bold(true)
- confirmMsg := fmt.Sprintf(
- "%s\n\n"+
- " Items: %d\n"+
- " Size: %s\n\n"+
- " Press [y] to confirm, [n] to cancel",
- warningStyle.Render("โ ๏ธ Confirm Deletion"),
- selectedCount,
- ui.FormatSize(selectedSize),
- )
+ pathStyle := lipgloss.NewStyle().
+ Foreground(lipgloss.Color("#EF4444"))
- b.WriteString(confirmBoxStyle.Render(confirmMsg))
- return b.String()
-}
+ sizeStyle := lipgloss.NewStyle().
+ Foreground(lipgloss.Color("#6B7280"))
-// renderSelection shows the item selection list
-func (m Model) renderSelection(b *strings.Builder) string {
- // Items list
- for i, item := range m.items {
- cursor := " "
- if i == m.cursor {
- cursor = cursorStyle.Render("โธ ")
- }
+ var confirmMsg strings.Builder
+ confirmMsg.WriteString(warningStyle.Render("โ ๏ธ Confirm Deletion"))
+ confirmMsg.WriteString("\n\n")
- checkbox := "[ ]"
- if m.selected[i] {
- checkbox = checkboxStyle.Render("[โ]")
- }
+ // Build list of paths to delete
+ confirmMsg.WriteString(" The following items will be PERMANENTLY DELETED:\n\n")
- // Type badge
- typeBadge := m.getTypeBadge(item.Type)
+ // Show paths - limit to first 8 items to avoid overflow
+ maxDisplay := 8
+ displayCount := 0
- // Size with color
- sizeStr := ui.FormatSize(item.Size)
- sizeStyle := lipgloss.NewStyle().Width(10).Align(lipgloss.Right)
- if item.Size > 1024*1024*1024 {
- sizeStyle = sizeStyle.Foreground(lipgloss.Color("#EF4444")).Bold(true)
- } else if item.Size > 100*1024*1024 {
- sizeStyle = sizeStyle.Foreground(lipgloss.Color("#F59E0B"))
- } else {
- sizeStyle = sizeStyle.Foreground(lipgloss.Color("#10B981"))
+ // Check if coming from tree mode (single item deletion)
+ if len(m.deletingItems) > 0 {
+ // Tree mode - show deletingItems
+ for i, item := range m.deletingItems {
+ if displayCount >= maxDisplay {
+ remaining := len(m.deletingItems) - maxDisplay
+ confirmMsg.WriteString(fmt.Sprintf(" ... and %d more items\n", remaining))
+ break
+ }
+ confirmMsg.WriteString(fmt.Sprintf(" %s %s %s\n",
+ pathStyle.Render("โ"),
+ sizeStyle.Render(fmt.Sprintf("[%s]", ui.FormatSize(item.Size))),
+ item.Path,
+ ))
+ displayCount++
+ _ = i
}
-
- line := fmt.Sprintf("%s%s %s %s %s",
- cursor,
- checkbox,
- typeBadge,
- sizeStyle.Render(sizeStr),
- item.Name,
- )
-
- if i == m.cursor {
- b.WriteString(selectedItemStyle.Render(line))
- } else {
- b.WriteString(itemStyle.Render(line))
+ } else {
+ // Normal selection mode - show selected items
+ for i, item := range m.items {
+ if !m.selected[i] {
+ continue
+ }
+ if displayCount >= maxDisplay {
+ remaining := selectedCount - maxDisplay
+ confirmMsg.WriteString(fmt.Sprintf(" ... and %d more items\n", remaining))
+ break
+ }
+ confirmMsg.WriteString(fmt.Sprintf(" %s %s %s\n",
+ pathStyle.Render("โ"),
+ sizeStyle.Render(fmt.Sprintf("[%s]", ui.FormatSize(item.Size))),
+ item.Path,
+ ))
+ displayCount++
}
- b.WriteString("\n")
}
+ confirmMsg.WriteString(fmt.Sprintf("\n Total: %d items โข %s\n\n", selectedCount, ui.FormatSize(selectedSize)))
+ confirmMsg.WriteString(" Press [y] to confirm, [n] to cancel")
+
+ b.WriteString(confirmBoxStyle.Render(confirmMsg.String()))
+ return b.String()
+}
+
+// renderSelection shows the item selection list using table
+func (m Model) renderSelection(b *strings.Builder) string {
+ // Render table (already updated in Update())
+ b.WriteString(m.itemsTable.View())
+ b.WriteString("\n")
+
// Status bar
selectedCount := m.countSelected()
selectedSize := m.selectedSize()
@@ -1481,7 +1739,8 @@ func (m Model) renderHelp(b *strings.Builder) string {
func (m Model) renderResults(b *strings.Builder) string {
if m.err != nil {
b.WriteString(errorStyle.Render(fmt.Sprintf("Error: %v", m.err)))
- b.WriteString("\n\nPress any key to rescan, q to quit.")
+ b.WriteString("\n\n")
+ b.WriteString(helpStyle.Render("r/Enter: Rescan โข Esc: Back โข q: Quit"))
return b.String()
}
@@ -1508,7 +1767,8 @@ func (m Model) renderResults(b *strings.Builder) string {
summary += fmt.Sprintf(" (%s freed)", ui.FormatSize(freedSize))
}
b.WriteString(successStyle.Render(summary))
- b.WriteString("\n\nPress any key to rescan, q to quit.")
+ b.WriteString("\n\n")
+ b.WriteString(helpStyle.Render("r/Enter: Rescan โข Esc: Back โข q: Quit"))
return b.String()
}
@@ -1599,7 +1859,6 @@ func (m Model) renderStatusBar() string {
center = "No items selected"
}
-
case StateTree:
// Left: State + Current path
if m.currentNode != nil {
@@ -1667,8 +1926,8 @@ func (m Model) renderStatusBar() string {
center = fmt.Sprintf("โ %d items โข %s freed", successCount, ui.FormatSize(freedSize))
}
- // Right: Total time + hints
- right = fmt.Sprintf("Total: %ds โข any key:rescan q:quit", int(elapsed.Seconds()))
+ // Right: Deletion time (frozen when completed) + hints
+ right = fmt.Sprintf("Total: %ds โข r:rescan esc:back q:quit", int(m.deleteDuration.Seconds()))
}
// Build status bar with sections
diff --git a/main.go b/main.go
index d667a2d..ec33374 100644
--- a/main.go
+++ b/main.go
@@ -1,6 +1,3 @@
-//go:build wails
-// +build wails
-
package main
import (
diff --git a/screens/image.png b/screens/image.png
new file mode 100644
index 0000000..46dca01
Binary files /dev/null and b/screens/image.png differ
diff --git a/screen1.png b/screens/screen1.png
similarity index 100%
rename from screen1.png
rename to screens/screen1.png
diff --git a/screen2.png b/screens/screen2.png
similarity index 100%
rename from screen2.png
rename to screens/screen2.png
diff --git a/wails.json b/wails.json
index 0bf1f11..17de4ac 100644
--- a/wails.json
+++ b/wails.json
@@ -1,6 +1,6 @@
{
"name": "Mac Dev Cleaner",
- "version": "1.0.0",
+ "version": "1.0.3",
"author": {
"name": "thanhdevapp",
"email": "thanhdevapp@gmail.com"
@@ -11,5 +11,6 @@
"frontend:install": "npm install",
"frontend:build": "npm run build",
"frontend:dev:watcher": "npm run dev",
- "frontend:dir": "./frontend"
+ "frontend:dir": "./frontend",
+ "go:build:tags": "wails"
}