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.
- cleanix/__init__.py +4 -0
- cleanix/__main__.py +6 -0
- cleanix/cleaners/__init__.py +269 -0
- cleanix/cleaners/ai_cli.py +193 -0
- cleanix/cleaners/ai_tools.py +224 -0
- cleanix/cleaners/app_cruft.py +201 -0
- cleanix/cleaners/apple_litter.py +41 -0
- cleanix/cleaners/apps.py +89 -0
- cleanix/cleaners/apt.py +70 -0
- cleanix/cleaners/base.py +173 -0
- cleanix/cleaners/broken_symlinks.py +51 -0
- cleanix/cleaners/browsers.py +68 -0
- cleanix/cleaners/bsd.py +108 -0
- cleanix/cleaners/containers.py +82 -0
- cleanix/cleaners/coredumps.py +32 -0
- cleanix/cleaners/desktop_extras.py +42 -0
- cleanix/cleaners/dev_caches.py +57 -0
- cleanix/cleaners/distro_pkg.py +127 -0
- cleanix/cleaners/dnf.py +56 -0
- cleanix/cleaners/editor_litter.py +115 -0
- cleanix/cleaners/font_cache.py +29 -0
- cleanix/cleaners/ide.py +87 -0
- cleanix/cleaners/kernels.py +115 -0
- cleanix/cleaners/lang_caches.py +70 -0
- cleanix/cleaners/linux_extras.py +77 -0
- cleanix/cleaners/localizations.py +70 -0
- cleanix/cleaners/logs.py +80 -0
- cleanix/cleaners/macos.py +166 -0
- cleanix/cleaners/macos_extra.py +125 -0
- cleanix/cleaners/memory.py +110 -0
- cleanix/cleaners/more_pkg.py +168 -0
- cleanix/cleaners/npm_cache.py +36 -0
- cleanix/cleaners/packaging_extras.py +140 -0
- cleanix/cleaners/pacman.py +63 -0
- cleanix/cleaners/pip_cache.py +27 -0
- cleanix/cleaners/snapshots.py +126 -0
- cleanix/cleaners/sys_extras.py +109 -0
- cleanix/cleaners/temp_files.py +48 -0
- cleanix/cleaners/thumbnails.py +31 -0
- cleanix/cleaners/trash.py +47 -0
- cleanix/cleaners/user_cache.py +69 -0
- cleanix/cleaners/virtualization.py +76 -0
- cleanix/cli.py +810 -0
- cleanix/completion.py +131 -0
- cleanix/config.py +225 -0
- cleanix/core/__init__.py +1 -0
- cleanix/core/context.py +147 -0
- cleanix/core/engine.py +155 -0
- cleanix/core/history.py +55 -0
- cleanix/core/models.py +141 -0
- cleanix/core/platform.py +117 -0
- cleanix/core/quarantine.py +147 -0
- cleanix/core/registry.py +58 -0
- cleanix/core/report.py +130 -0
- cleanix/core/safety.py +166 -0
- cleanix/core/utils.py +244 -0
- cleanix/reset.py +328 -0
- cleanix/scheduler/__init__.py +1 -0
- cleanix/scheduler/systemd.py +160 -0
- cleanix_cli-1.0.1.dist-info/METADATA +436 -0
- cleanix_cli-1.0.1.dist-info/RECORD +64 -0
- cleanix_cli-1.0.1.dist-info/WHEEL +5 -0
- cleanix_cli-1.0.1.dist-info/entry_points.txt +2 -0
- cleanix_cli-1.0.1.dist-info/top_level.txt +1 -0
cleanix/__init__.py
ADDED
cleanix/__main__.py
ADDED
|
@@ -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
|