cleanix-cli 1.0.1__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (64) hide show
  1. cleanix/__init__.py +4 -0
  2. cleanix/__main__.py +6 -0
  3. cleanix/cleaners/__init__.py +269 -0
  4. cleanix/cleaners/ai_cli.py +193 -0
  5. cleanix/cleaners/ai_tools.py +224 -0
  6. cleanix/cleaners/app_cruft.py +201 -0
  7. cleanix/cleaners/apple_litter.py +41 -0
  8. cleanix/cleaners/apps.py +89 -0
  9. cleanix/cleaners/apt.py +70 -0
  10. cleanix/cleaners/base.py +173 -0
  11. cleanix/cleaners/broken_symlinks.py +51 -0
  12. cleanix/cleaners/browsers.py +68 -0
  13. cleanix/cleaners/bsd.py +108 -0
  14. cleanix/cleaners/containers.py +82 -0
  15. cleanix/cleaners/coredumps.py +32 -0
  16. cleanix/cleaners/desktop_extras.py +42 -0
  17. cleanix/cleaners/dev_caches.py +57 -0
  18. cleanix/cleaners/distro_pkg.py +127 -0
  19. cleanix/cleaners/dnf.py +56 -0
  20. cleanix/cleaners/editor_litter.py +115 -0
  21. cleanix/cleaners/font_cache.py +29 -0
  22. cleanix/cleaners/ide.py +87 -0
  23. cleanix/cleaners/kernels.py +115 -0
  24. cleanix/cleaners/lang_caches.py +70 -0
  25. cleanix/cleaners/linux_extras.py +77 -0
  26. cleanix/cleaners/localizations.py +70 -0
  27. cleanix/cleaners/logs.py +80 -0
  28. cleanix/cleaners/macos.py +166 -0
  29. cleanix/cleaners/macos_extra.py +125 -0
  30. cleanix/cleaners/memory.py +110 -0
  31. cleanix/cleaners/more_pkg.py +168 -0
  32. cleanix/cleaners/npm_cache.py +36 -0
  33. cleanix/cleaners/packaging_extras.py +140 -0
  34. cleanix/cleaners/pacman.py +63 -0
  35. cleanix/cleaners/pip_cache.py +27 -0
  36. cleanix/cleaners/snapshots.py +126 -0
  37. cleanix/cleaners/sys_extras.py +109 -0
  38. cleanix/cleaners/temp_files.py +48 -0
  39. cleanix/cleaners/thumbnails.py +31 -0
  40. cleanix/cleaners/trash.py +47 -0
  41. cleanix/cleaners/user_cache.py +69 -0
  42. cleanix/cleaners/virtualization.py +76 -0
  43. cleanix/cli.py +810 -0
  44. cleanix/completion.py +131 -0
  45. cleanix/config.py +225 -0
  46. cleanix/core/__init__.py +1 -0
  47. cleanix/core/context.py +147 -0
  48. cleanix/core/engine.py +155 -0
  49. cleanix/core/history.py +55 -0
  50. cleanix/core/models.py +141 -0
  51. cleanix/core/platform.py +117 -0
  52. cleanix/core/quarantine.py +147 -0
  53. cleanix/core/registry.py +58 -0
  54. cleanix/core/report.py +130 -0
  55. cleanix/core/safety.py +166 -0
  56. cleanix/core/utils.py +244 -0
  57. cleanix/reset.py +328 -0
  58. cleanix/scheduler/__init__.py +1 -0
  59. cleanix/scheduler/systemd.py +160 -0
  60. cleanix_cli-1.0.1.dist-info/METADATA +436 -0
  61. cleanix_cli-1.0.1.dist-info/RECORD +64 -0
  62. cleanix_cli-1.0.1.dist-info/WHEEL +5 -0
  63. cleanix_cli-1.0.1.dist-info/entry_points.txt +2 -0
  64. cleanix_cli-1.0.1.dist-info/top_level.txt +1 -0
cleanix/__init__.py ADDED
@@ -0,0 +1,4 @@
1
+ """Cleanix — a safe, thorough scheduled system cleaner for Linux, macOS and BSD."""
2
+
3
+ __version__ = "1.0.1"
4
+ __all__ = ["__version__"]
cleanix/__main__.py ADDED
@@ -0,0 +1,6 @@
1
+ """Enable ``python -m cleanix``."""
2
+
3
+ from cleanix.cli import main
4
+
5
+ if __name__ == "__main__":
6
+ raise SystemExit(main())
@@ -0,0 +1,269 @@
1
+ """Built-in cleaners.
2
+
3
+ Each module defines one or more :class:`~cleanix.cleaners.base.Cleaner`
4
+ subclasses. :data:`ALL_CLEANERS` is the ordered registry consumed by the
5
+ engine. Cleaners declare which platforms they apply to; the engine only runs
6
+ the ones relevant to the current operating system.
7
+ """
8
+
9
+ from __future__ import annotations
10
+
11
+ from typing import List, Type
12
+
13
+ from cleanix.cleaners.base import Cleaner
14
+
15
+ # Cross-platform / freedesktop
16
+ from cleanix.cleaners.trash import TrashCleaner
17
+ from cleanix.cleaners.thumbnails import ThumbnailCleaner
18
+ from cleanix.cleaners.user_cache import UserCacheCleaner
19
+ from cleanix.cleaners.temp_files import TempFilesCleaner
20
+ from cleanix.cleaners.font_cache import FontCacheCleaner
21
+ from cleanix.cleaners.browsers import BrowserCacheCleaner
22
+ from cleanix.cleaners.broken_symlinks import BrokenSymlinkCleaner
23
+ from cleanix.cleaners.apple_litter import AppleLitterCleaner
24
+ from cleanix.cleaners.dev_caches import DevCacheCleaner
25
+ from cleanix.cleaners.pip_cache import PipCacheCleaner
26
+ from cleanix.cleaners.npm_cache import NpmCacheCleaner
27
+ from cleanix.cleaners.containers import DockerCleaner, PodmanCleaner
28
+
29
+ # Logs / crashes
30
+ from cleanix.cleaners.logs import JournalCleaner, RotatedLogCleaner
31
+ from cleanix.cleaners.coredumps import CoredumpCleaner
32
+ from cleanix.cleaners.linux_extras import ConfigLeftoverCleaner, CrashReportCleaner
33
+
34
+ # Linux package managers
35
+ from cleanix.cleaners.apt import AptCleaner
36
+ from cleanix.cleaners.dnf import DnfCleaner
37
+ from cleanix.cleaners.pacman import PacmanCleaner
38
+ from cleanix.cleaners.distro_pkg import (
39
+ ApkCleaner,
40
+ PortageCleaner,
41
+ XbpsCleaner,
42
+ ZypperCleaner,
43
+ )
44
+ from cleanix.cleaners.packaging_extras import (
45
+ AppImageCruftCleaner,
46
+ FlatpakCleaner,
47
+ NixGcCleaner,
48
+ SnapCleaner,
49
+ )
50
+
51
+ # macOS
52
+ from cleanix.cleaners.macos import (
53
+ HomebrewCleaner,
54
+ MacDiagnosticsCleaner,
55
+ MacPortsCleaner,
56
+ MacTrashCleaner,
57
+ MacUserCacheCleaner,
58
+ XcodeCleaner,
59
+ )
60
+
61
+ # AI / LLM tools
62
+ from cleanix.cleaners.ai_tools import (
63
+ AIClientCleaner,
64
+ AICompileCacheCleaner,
65
+ AiderLitterCleaner,
66
+ HuggingFaceCleaner,
67
+ OllamaCleaner,
68
+ )
69
+
70
+ # AI coding-agent CLIs (Claude Code, Codex, Gemini CLI, OpenCode)
71
+ from cleanix.cleaners.ai_cli import (
72
+ ClaudeCodeCleaner,
73
+ CodexCleaner,
74
+ GeminiCliCleaner,
75
+ OpenCodeCleaner,
76
+ )
77
+
78
+ # General desktop-app cruft
79
+ from cleanix.cleaners.app_cruft import (
80
+ ElectronCacheCleaner,
81
+ FlatpakAppCacheCleaner,
82
+ GpuShaderCacheCleaner,
83
+ JetBrainsCleaner,
84
+ SteamCleaner,
85
+ )
86
+
87
+ # Additional system leftovers
88
+ from cleanix.cleaners.sys_extras import (
89
+ CrashSpoolCleaner,
90
+ OfflineUpdateCleaner,
91
+ SystemCacheCleaner,
92
+ VarBackupsCleaner,
93
+ )
94
+ from cleanix.cleaners.kernels import OldKernelCleaner
95
+ from cleanix.cleaners.localizations import LocalePurgeCleaner
96
+
97
+ # Language / toolchain caches
98
+ from cleanix.cleaners.lang_caches import LangPackageCacheCleaner
99
+
100
+ # Desktop search indexes
101
+ from cleanix.cleaners.desktop_extras import SearchIndexCleaner
102
+
103
+ # Virtualization / cloud
104
+ from cleanix.cleaners.virtualization import LibvirtSaveReporter, VmToolingCleaner
105
+
106
+ # Editor / build litter
107
+ from cleanix.cleaners.editor_litter import (
108
+ BackupFileCleaner,
109
+ BuildLitterCleaner,
110
+ EditorStateCleaner,
111
+ HomeCoreDumpCleaner,
112
+ )
113
+
114
+ # Backups & snapshots (mostly report-only)
115
+ from cleanix.cleaners.snapshots import (
116
+ BackupCacheCleaner,
117
+ DeviceBackupReporter,
118
+ SnapshotReporter,
119
+ TimeMachineReporter,
120
+ )
121
+
122
+ # IDEs, apps, memory
123
+ from cleanix.cleaners.ide import IdeCleaner
124
+ from cleanix.cleaners.apps import AppLeftoverCleaner, SnapAppCacheCleaner
125
+ from cleanix.cleaners.memory import (
126
+ DropCachesCleaner,
127
+ MacMemoryPurgeCleaner,
128
+ SwapReclaimCleaner,
129
+ )
130
+
131
+ # More package managers
132
+ from cleanix.cleaners.more_pkg import (
133
+ CondaCleaner,
134
+ CpanmCleaner,
135
+ EopkgCleaner,
136
+ GemCleanupCleaner,
137
+ GuixCleaner,
138
+ OpamCleaner,
139
+ SdkmanCleaner,
140
+ SwupdCleaner,
141
+ )
142
+
143
+ # macOS extras
144
+ from cleanix.cleaners.macos_extra import (
145
+ MacContainerCacheCleaner,
146
+ MacExtraCachesCleaner,
147
+ MacFontCacheCleaner,
148
+ MacSleepImageReporter,
149
+ MacSystemCacheCleaner,
150
+ )
151
+
152
+ # BSD
153
+ from cleanix.cleaners.bsd import (
154
+ BsdDistfilesCleaner,
155
+ FreeBsdPkgCleaner,
156
+ PkginCleaner,
157
+ )
158
+
159
+ ALL_CLEANERS: List[Type[Cleaner]] = [
160
+ # Cross-platform user junk
161
+ TrashCleaner,
162
+ ThumbnailCleaner,
163
+ UserCacheCleaner,
164
+ TempFilesCleaner,
165
+ FontCacheCleaner,
166
+ BrowserCacheCleaner,
167
+ BrokenSymlinkCleaner,
168
+ AppleLitterCleaner,
169
+ DevCacheCleaner,
170
+ PipCacheCleaner,
171
+ NpmCacheCleaner,
172
+ DockerCleaner,
173
+ PodmanCleaner,
174
+ # Logs & crashes
175
+ RotatedLogCleaner,
176
+ JournalCleaner,
177
+ CoredumpCleaner,
178
+ CrashReportCleaner,
179
+ ConfigLeftoverCleaner,
180
+ # Linux package managers
181
+ AptCleaner,
182
+ DnfCleaner,
183
+ PacmanCleaner,
184
+ ZypperCleaner,
185
+ ApkCleaner,
186
+ XbpsCleaner,
187
+ PortageCleaner,
188
+ EopkgCleaner,
189
+ SwupdCleaner,
190
+ GuixCleaner,
191
+ CondaCleaner,
192
+ OpamCleaner,
193
+ SdkmanCleaner,
194
+ GemCleanupCleaner,
195
+ CpanmCleaner,
196
+ # Universal/sandbox package formats
197
+ FlatpakCleaner,
198
+ SnapCleaner,
199
+ NixGcCleaner,
200
+ AppImageCruftCleaner,
201
+ # AI / LLM engines and clients
202
+ OllamaCleaner,
203
+ HuggingFaceCleaner,
204
+ AICompileCacheCleaner,
205
+ AIClientCleaner,
206
+ AiderLitterCleaner,
207
+ # AI coding-agent CLIs
208
+ ClaudeCodeCleaner,
209
+ CodexCleaner,
210
+ GeminiCliCleaner,
211
+ OpenCodeCleaner,
212
+ # Desktop-app cruft
213
+ ElectronCacheCleaner,
214
+ FlatpakAppCacheCleaner,
215
+ GpuShaderCacheCleaner,
216
+ SteamCleaner,
217
+ JetBrainsCleaner,
218
+ # Language / toolchain caches
219
+ LangPackageCacheCleaner,
220
+ # Desktop search indexes & activity
221
+ SearchIndexCleaner,
222
+ # IDEs & applications
223
+ IdeCleaner,
224
+ AppLeftoverCleaner,
225
+ SnapAppCacheCleaner,
226
+ # Memory (opt-in via --only)
227
+ DropCachesCleaner,
228
+ SwapReclaimCleaner,
229
+ MacMemoryPurgeCleaner,
230
+ # Editor / build litter
231
+ EditorStateCleaner,
232
+ BuildLitterCleaner,
233
+ HomeCoreDumpCleaner,
234
+ BackupFileCleaner,
235
+ # Virtualization / cloud
236
+ VmToolingCleaner,
237
+ LibvirtSaveReporter,
238
+ # Additional system leftovers
239
+ SystemCacheCleaner,
240
+ VarBackupsCleaner,
241
+ CrashSpoolCleaner,
242
+ OfflineUpdateCleaner,
243
+ OldKernelCleaner,
244
+ LocalePurgeCleaner,
245
+ # Backups & snapshots (report-only tier)
246
+ BackupCacheCleaner,
247
+ SnapshotReporter,
248
+ TimeMachineReporter,
249
+ DeviceBackupReporter,
250
+ # macOS extras
251
+ MacExtraCachesCleaner,
252
+ MacContainerCacheCleaner,
253
+ MacSystemCacheCleaner,
254
+ MacFontCacheCleaner,
255
+ MacSleepImageReporter,
256
+ # macOS
257
+ MacUserCacheCleaner,
258
+ MacTrashCleaner,
259
+ MacDiagnosticsCleaner,
260
+ HomebrewCleaner,
261
+ MacPortsCleaner,
262
+ XcodeCleaner,
263
+ # BSD
264
+ FreeBsdPkgCleaner,
265
+ BsdDistfilesCleaner,
266
+ PkginCleaner,
267
+ ]
268
+
269
+ __all__ = ["ALL_CLEANERS", "Cleaner"]
@@ -0,0 +1,193 @@
1
+ """Leftovers from AI coding-agent CLIs.
2
+
3
+ These tools quietly accumulate a lot on disk: rolling config backups, per-session
4
+ file-edit history/checkpoints, conversation transcripts, per-session todo lists,
5
+ debug logs, and telemetry. This module *triages* them:
6
+
7
+ - **Rolling backups** → keep the newest ``keep_backups`` (default 2), remove the
8
+ older surplus. This is the "keep max N backups" the user asked for.
9
+ - **Transcripts / file-history / logs** → offered only once older than
10
+ ``ai_history_max_age_days`` (default 30d), since they are conversation data.
11
+ - **Ephemeral scratch** (debug, todos, shell snapshots, telemetry, caches) →
12
+ offered outright, skipping anything modified very recently (in-use guard).
13
+
14
+ Config/auth/plugins are never touched. Covers Claude Code, OpenAI Codex,
15
+ Gemini CLI, and OpenCode.
16
+ """
17
+
18
+ from __future__ import annotations
19
+
20
+ import os
21
+ from pathlib import Path
22
+ from typing import Iterable, List
23
+
24
+ from cleanix.cleaners.base import Cleaner
25
+ from cleanix.core.models import CleanableItem
26
+ from cleanix.core.utils import data_dir
27
+ from cleanix.core.utils import (
28
+ home,
29
+ iter_children,
30
+ modified_within,
31
+ older_than,
32
+ surplus_after_keeping,
33
+ )
34
+
35
+
36
+ class _AgentCleaner(Cleaner):
37
+ """Shared helpers for AI-CLI cleaners."""
38
+
39
+ requires_root = False
40
+
41
+ def _ephemeral_children(
42
+ self, directory: Path, label: str, guard_minutes: float | None = None
43
+ ) -> Iterable[CleanableItem]:
44
+ """Offer each child of a scratch dir, skipping freshly-written ones.
45
+
46
+ ``guard_minutes`` sets how recently-modified an entry must be to be
47
+ left alone. Use a large value (e.g. a day) for per-session state that
48
+ might belong to a currently-running session.
49
+ """
50
+ if not directory.is_dir():
51
+ return
52
+ guard = (
53
+ self.config.cache_min_age_minutes
54
+ if guard_minutes is None
55
+ else guard_minutes
56
+ )
57
+ for child in iter_children(directory):
58
+ if modified_within(child, guard):
59
+ continue
60
+ item = self.path_item(child, f"{label}: {child.name}")
61
+ if item:
62
+ yield item
63
+
64
+ def _stale_children(self, directory: Path, label: str) -> Iterable[CleanableItem]:
65
+ """Offer children older than the history-retention age."""
66
+ if not directory.is_dir():
67
+ return
68
+ age = self.config.ai_history_max_age_days
69
+ for child in iter_children(directory):
70
+ if not older_than(child, age):
71
+ continue
72
+ item = self.path_item(child, f"{label}: {child.name}")
73
+ if item:
74
+ yield item
75
+
76
+
77
+ class ClaudeCodeCleaner(_AgentCleaner):
78
+ id = "claude_code"
79
+ name = "Claude Code leftovers"
80
+ description = "Old backups, file-history, transcripts, debug logs & scratch"
81
+
82
+ def _root(self) -> Path:
83
+ return home() / ".claude"
84
+
85
+ def find_items(self) -> Iterable[CleanableItem]:
86
+ root = self._root()
87
+ if not root.is_dir():
88
+ return
89
+
90
+ # 1) Rolling config backups: keep newest N, offer the surplus.
91
+ backups = root / "backups"
92
+ if backups.is_dir():
93
+ files = [c for c in iter_children(backups) if c.is_file()]
94
+ for old in surplus_after_keeping(files, self.config.keep_backups):
95
+ item = self.path_item(
96
+ old, f"Old Claude backup: {old.name}"
97
+ )
98
+ if item:
99
+ yield item
100
+
101
+ # 2a) Always-safe scratch — short in-use guard is enough.
102
+ for sub, label in (
103
+ ("debug", "Claude debug log"),
104
+ ("statsig", "Claude telemetry cache"),
105
+ ("paste-cache", "Claude paste cache"),
106
+ ("downloads", "Claude download"),
107
+ ("cache", "Claude cache"),
108
+ ):
109
+ yield from self._ephemeral_children(root / sub, label)
110
+
111
+ # 2b) Per-session scratch that may belong to a *running* session — keep
112
+ # anything touched in the last day so we never disturb an active run.
113
+ _DAY = 24 * 60
114
+ for sub, label in (
115
+ ("todos", "Claude session todos"),
116
+ ("shell-snapshots", "Claude shell snapshot"),
117
+ ("session-env", "Claude session env"),
118
+ ):
119
+ yield from self._ephemeral_children(root / sub, label, guard_minutes=_DAY)
120
+
121
+ # 3) Per-session file-edit history — offer sessions older than retention.
122
+ yield from self._stale_children(root / "file-history", "Claude file-history")
123
+
124
+ # 4) Conversation transcripts — age-gated (this is your history).
125
+ projects = root / "projects"
126
+ if projects.is_dir():
127
+ for proj in iter_children(projects):
128
+ yield from self._stale_children(proj, f"Claude transcript ({proj.name})")
129
+
130
+
131
+ class CodexCleaner(_AgentCleaner):
132
+ id = "codex"
133
+ name = "OpenAI Codex CLI leftovers"
134
+ description = "Old session rollouts and TUI logs under ~/.codex"
135
+
136
+ def _root(self) -> Path:
137
+ override = os.environ.get("CODEX_HOME")
138
+ return Path(override) if override else home() / ".codex"
139
+
140
+ def find_items(self) -> Iterable[CleanableItem]:
141
+ root = self._root()
142
+ if not root.is_dir():
143
+ return
144
+ # sessions/YYYY/MM/DD/rollout-*.jsonl — offer files older than retention.
145
+ sessions = root / "sessions"
146
+ if sessions.is_dir():
147
+ age = self.config.ai_history_max_age_days
148
+ for dirpath, _dirs, files in os.walk(sessions, onerror=lambda e: None):
149
+ for name in files:
150
+ p = Path(dirpath, name)
151
+ if older_than(p, age):
152
+ item = self.path_item(p, f"Codex session: {name}")
153
+ if item:
154
+ yield item
155
+ # logs.
156
+ yield from self._ephemeral_children(root / "logs", "Codex log")
157
+
158
+
159
+ class GeminiCliCleaner(_AgentCleaner):
160
+ id = "gemini_cli"
161
+ name = "Gemini CLI leftovers"
162
+ description = "Old per-project session/log data under ~/.gemini/tmp"
163
+
164
+ def _root(self) -> Path:
165
+ return home() / ".gemini"
166
+
167
+ def find_items(self) -> Iterable[CleanableItem]:
168
+ tmp = self._root() / "tmp"
169
+ if not tmp.is_dir():
170
+ return
171
+ # Each project hash dir holds chats/ and logs.json; age-gate them.
172
+ yield from self._stale_children(tmp, "Gemini session data")
173
+
174
+
175
+ class OpenCodeCleaner(_AgentCleaner):
176
+ id = "opencode"
177
+ name = "OpenCode leftovers"
178
+ description = "Logs, snapshots, and tool output (keeps DB/auth/storage)"
179
+
180
+ def _root(self) -> Path:
181
+ base = str(data_dir())
182
+ return Path(base) / "opencode"
183
+
184
+ def find_items(self) -> Iterable[CleanableItem]:
185
+ root = self._root()
186
+ if not root.is_dir():
187
+ return
188
+ for sub, label in (
189
+ ("log", "OpenCode log"),
190
+ ("tool-output", "OpenCode tool output"),
191
+ ("snapshot", "OpenCode snapshot"),
192
+ ):
193
+ yield from self._ephemeral_children(root / sub, label)
@@ -0,0 +1,224 @@
1
+ """Leftovers from locally-installed AI / LLM engines and clients.
2
+
3
+ The guiding principle is *triage*: remove genuinely disposable junk — dangling
4
+ model blobs from interrupted pulls, ``*.incomplete`` downloads, compile/JIT
5
+ kernel caches, embeddings indexes, and logs — while never wholesale-deleting the
6
+ models you deliberately downloaded or your chat history.
7
+
8
+ Covered: Ollama, Hugging Face Hub, PyTorch/Triton/vLLM/CUDA compile caches,
9
+ LM Studio, Jan, Continue.dev, Claude, and Aider project litter.
10
+ """
11
+
12
+ from __future__ import annotations
13
+
14
+ import json
15
+ import os
16
+ from pathlib import Path
17
+ from typing import Iterable, Set
18
+
19
+ from cleanix.cleaners.base import Cleaner
20
+ from cleanix.core.context import current_user
21
+ from cleanix.core.models import CleanableItem
22
+ from cleanix.core.utils import (
23
+ home,
24
+ iter_children,
25
+ modified_within,
26
+ path_size,
27
+ walk_pruned,
28
+ which,
29
+ )
30
+
31
+
32
+ class OllamaCleaner(Cleaner):
33
+ id = "ollama"
34
+ name = "Ollama dangling blobs"
35
+ description = "Orphaned model blobs from interrupted pulls, plus logs"
36
+ requires_root = False
37
+
38
+ def _models_dir(self) -> Path:
39
+ # Honor the env override only for the user who launched cleanix; when
40
+ # sweeping other users' homes we must not project their env onto ours.
41
+ override = os.environ.get("OLLAMA_MODELS")
42
+ if override and current_user().is_invoker:
43
+ return Path(override)
44
+ return home() / ".ollama" / "models"
45
+
46
+ def _referenced_digests(self, manifests: Path) -> Set[str]:
47
+ """Collect every blob digest referenced by a manifest."""
48
+ referenced: Set[str] = set()
49
+ if not manifests.is_dir():
50
+ return referenced
51
+ for dirpath, _dirs, files in walk_pruned(manifests, prune=set()):
52
+ for name in files:
53
+ try:
54
+ data = json.loads(Path(dirpath, name).read_text())
55
+ except (OSError, ValueError):
56
+ continue
57
+ digests = []
58
+ cfg = data.get("config", {})
59
+ if isinstance(cfg, dict) and cfg.get("digest"):
60
+ digests.append(cfg["digest"])
61
+ for layer in data.get("layers", []) or []:
62
+ if isinstance(layer, dict) and layer.get("digest"):
63
+ digests.append(layer["digest"])
64
+ # Manifest stores "sha256:abc"; blob files are "sha256-abc".
65
+ for d in digests:
66
+ referenced.add(d.replace(":", "-"))
67
+ return referenced
68
+
69
+ def find_items(self) -> Iterable[CleanableItem]:
70
+ models = self._models_dir()
71
+ blobs = models / "blobs"
72
+ manifests = models / "manifests"
73
+
74
+ # Only act if we can see a populated manifest set (i.e. the store is
75
+ # really here and we can tell what's referenced).
76
+ referenced = self._referenced_digests(manifests)
77
+ if blobs.is_dir() and referenced:
78
+ for blob in iter_children(blobs):
79
+ if blob.name in referenced:
80
+ continue
81
+ # Skip blobs that might be part of an in-progress pull.
82
+ if modified_within(blob, 60):
83
+ continue
84
+ item = self.path_item(blob, f"Dangling Ollama blob: {blob.name}")
85
+ if item:
86
+ yield item
87
+
88
+ # Ollama server logs.
89
+ logs = home() / ".ollama" / "logs"
90
+ if logs.is_dir():
91
+ for log in iter_children(logs):
92
+ item = self.path_item(log, f"Ollama log: {log.name}")
93
+ if item:
94
+ yield item
95
+
96
+
97
+ class HuggingFaceCleaner(Cleaner):
98
+ id = "huggingface"
99
+ name = "Hugging Face cache junk"
100
+ description = "Incomplete downloads and stale lock files (keeps models)"
101
+ requires_root = False
102
+
103
+ def _roots(self) -> Iterable[Path]:
104
+ base = os.environ.get("HF_HOME")
105
+ roots = [Path(base)] if base and current_user().is_invoker else []
106
+ roots.append(home() / ".cache" / "huggingface")
107
+ for r in roots:
108
+ if r.is_dir():
109
+ yield r
110
+
111
+ def find_items(self) -> Iterable[CleanableItem]:
112
+ seen: Set[str] = set()
113
+ for root in self._roots():
114
+ # Interrupted downloads: blobs/<etag>.incomplete
115
+ for dirpath, _dirs, files in walk_pruned(root, prune={".no_exist"}):
116
+ for name in files:
117
+ if name.endswith(".incomplete"):
118
+ p = os.path.join(dirpath, name)
119
+ if p in seen:
120
+ continue
121
+ seen.add(p)
122
+ item = self.path_item(p, f"HF incomplete download: {name}")
123
+ if item:
124
+ yield item
125
+ # Lock files and negative-lookup cache — always safe to drop.
126
+ for rel in ("hub/.locks", ".locks", "hub/.no_exist"):
127
+ target = root / rel
128
+ if target.exists():
129
+ item = self.path_item(target, f"HF {rel}")
130
+ if item:
131
+ yield item
132
+
133
+
134
+ class AICompileCacheCleaner(Cleaner):
135
+ id = "ai_compile_cache"
136
+ name = "AI compile/kernel caches"
137
+ description = "Triton, torch.compile/inductor, vLLM, CUDA JIT kernel caches"
138
+ requires_root = False
139
+
140
+ def _candidates(self):
141
+ h = home()
142
+ cache = h / ".cache"
143
+ user = current_user().name or ""
144
+ yield h / ".triton" / "cache", "Triton kernel cache"
145
+ yield cache / "torch_extensions", "PyTorch JIT extensions cache"
146
+ yield cache / "vllm", "vLLM torch.compile cache"
147
+ yield h / ".nv" / "ComputeCache", "CUDA compute (PTX JIT) cache"
148
+ yield cache / "flashinfer", "FlashInfer JIT cache"
149
+ yield cache / "tfhub_modules", "TensorFlow Hub module cache"
150
+ if user:
151
+ yield Path("/tmp") / f"torchinductor_{user}", "TorchInductor cache (/tmp)"
152
+ yield Path("/tmp") / f"triton_{user}", "Triton cache (/tmp)"
153
+
154
+ def find_items(self) -> Iterable[CleanableItem]:
155
+ seen = set()
156
+ for path, label in self._candidates():
157
+ if path in seen or not path.exists() or path_size(path) <= 0:
158
+ continue
159
+ seen.add(path)
160
+ item = self.path_item(path, label)
161
+ if item:
162
+ yield item
163
+
164
+
165
+ class AIClientCleaner(Cleaner):
166
+ id = "ai_clients"
167
+ name = "AI client leftovers"
168
+ description = "Logs & rebuildable indexes for LM Studio, Jan, Continue, Claude"
169
+ requires_root = False
170
+
171
+ def _candidates(self):
172
+ h = home()
173
+ # LM Studio — logs only (never the models/config store).
174
+ yield h / ".cache" / "lm-studio" / "server-logs", "LM Studio server logs"
175
+ yield h / ".lmstudio" / "server-logs", "LM Studio server logs"
176
+ yield h / ".lmstudio" / "logs", "LM Studio logs"
177
+ # Jan — logs.
178
+ yield h / ".config" / "Jan" / "logs", "Jan logs"
179
+ yield h / "jan" / "logs", "Jan logs"
180
+ # Continue.dev — rebuildable embeddings index, logs, telemetry.
181
+ yield h / ".continue" / "index", "Continue.dev index (rebuildable)"
182
+ yield h / ".continue" / "logs", "Continue.dev logs"
183
+ yield h / ".continue" / "dev_data", "Continue.dev telemetry data"
184
+ # (Claude Code is handled by the dedicated claude_code cleaner.)
185
+ # Open WebUI / text-generation-webui logs.
186
+ yield h / ".cache" / "chroma", "Chroma vector DB cache"
187
+
188
+ def find_items(self) -> Iterable[CleanableItem]:
189
+ for path, label in self._candidates():
190
+ if path.exists() and path_size(path) > 0:
191
+ item = self.path_item(path, label)
192
+ if item:
193
+ yield item
194
+
195
+
196
+ class AiderLitterCleaner(Cleaner):
197
+ id = "aider"
198
+ name = "Aider project litter"
199
+ description = "Stray .aider.* history/cache files left in project folders"
200
+ requires_root = False
201
+
202
+ _NAMES = (
203
+ ".aider.chat.history.md",
204
+ ".aider.input.history",
205
+ ".aider.llm.history",
206
+ )
207
+ _PREFIXES = (".aider.tags.cache",)
208
+
209
+ def find_items(self) -> Iterable[CleanableItem]:
210
+ root = home()
211
+ for dirpath, dirs, files in walk_pruned(root):
212
+ # .aider.tags.cache.v3 is a directory; catch it as we descend.
213
+ for d in list(dirs):
214
+ if d.startswith(self._PREFIXES):
215
+ p = os.path.join(dirpath, d)
216
+ item = self.path_item(p, f"Aider cache: {p}")
217
+ if item:
218
+ yield item
219
+ for name in files:
220
+ if name in self._NAMES or name.startswith(self._PREFIXES):
221
+ p = os.path.join(dirpath, name)
222
+ item = self.path_item(p, f"Aider leftover: {p}")
223
+ if item:
224
+ yield item