AGENT_QUICK_REF.txt
╔══════════════════════════════════════════════════════════════════════════════╗
║ DISK CLEANER - UNIVERSAL AGENT QUICK REFERENCE CARD ║
║ (Works with ALL AI IDEs on ALL platforms) ║
╚══════════════════════════════════════════════════════════════════════════════╝
┌─ UNIVERSAL REQUIREMENTS ────────────────────────────────────────────────────┐
│ │
│ ✅ Python 3.7+ (ONLY requirement) │
│ ✅ Works on: Windows, macOS, Linux │
│ ✅ Works with: Cursor, Windsurf, Continue, Aider, Claude Code, etc. │
│ ✅ Works at: Global, Project, or User level │
│ ✅ NO pip install needed (self-contained) │
│ │
└──────────────────────────────────────────────────────────────────────────────┘
┌─ STEP 1: DETECT PYTHON (PLATFORM AGNOSTIC) ───────────────────────────────┐
│ │
│ import subprocess, os │
│ │
│ # Use 'python' on Windows, 'python3' on Unix │
│ python_cmd = 'python' if os.name == 'nt' else 'python3' │
│ │
│ result = subprocess.run([python_cmd, '--version'], │
│ capture_output=True, text=True) │
│ if result.returncode != 0: │
│ print("ERROR: Python 3.7+ required") │
│ print("Install: https://www.python.org/downloads/") │
│ return False │
│ │
│ print(f"OK: Python {result.stderr.strip()}") │
│ │
└──────────────────────────────────────────────────────────────────────────────┘
┌─ STEP 2: FIND SKILL PACKAGE (LOCATION INDEPENDENT) ───────────────────────┐
│ │
│ from pathlib import Path │
│ │
│ # Search in order of priority (works everywhere) │
│ search_paths = [ │
│ # Current directory │
│ Path.cwd() / 'disk-cleaner', │
│ Path.cwd() / 'skills' / 'disk-cleaner', │
│ Path.cwd() / '.skills' / 'disk-cleaner', │
│ # Project root (up to 3 levels) │
│ *[p / 'skills' / 'disk-cleaner' │
│ for p in [Path.cwd(), *Path.cwd().parents][:3]], │
│ # User home (universal) │
│ Path.home() / 'skills' / 'disk-cleaner', │
│ Path.home() / '.skills' / 'disk-cleaner', │
│ ] │
│ │
│ # Find valid skill package │
│ skill_path = None │
│ for path in search_paths: │
│ if (path / 'scripts' / 'analyze_disk.py').exists(): │
│ skill_path = path │
│ break │
│ │
│ if not skill_path: │
│ print("ERROR: Skill package not found") │
│ print("Extract to: skills/disk-cleaner/ or ~/.skills/disk-cleaner/") │
│ return False │
│ │
│ print(f"OK: Found at {skill_path}") │
│ │
└──────────────────────────────────────────────────────────────────────────────┘
┌─ STEP 3: VERIFY SKILL (OPTIONAL BUT RECOMMENDED) ──────────────────────────┐
│ │
│ result = subprocess.run( │
│ [python_cmd, 'scripts/check_skill.py'], │
│ cwd=str(skill_path), │
│ capture_output=True, text=True │
│ ) │
│ │
│ if result.returncode != 0: │
│ print("ERROR: Skill verification failed") │
│ print(result.stdout) │
│ return False │
│ │
│ print("OK: Skill verified") │
│ │
└──────────────────────────────────────────────────────────────────────────────┘
┌─ STEP 4: EXECUTE OPERATION ─────────────────────────────────────────────────┐
│ │
│ operations = { │
│ 'analyze': 'analyze_disk.py', │
│ 'clean': 'clean_disk.py', │
│ 'monitor': 'monitor_disk.py', │
│ } │
│ │
│ script = skill_path / 'scripts' / operations[operation] │
│ cmd = [python_cmd, str(script)] │
│ │
│ # Add operation-specific args │
│ if operation == 'analyze' and target_path: │
│ cmd.extend(['--path', str(target_path)]) │
│ elif operation == 'clean': │
│ cmd.append('--dry-run') # ALWAYS use dry-run first! │
│ │
│ result = subprocess.run(cmd, cwd=str(skill_path), │
│ capture_output=True, text=True) │
│ │
│ print(result.stdout) │
│ │
└──────────────────────────────────────────────────────────────────────────────┘
┌─ USER INTENT MAPPING ──────────────────────────────────────────────────────┐
│ │
│ User says any of: → Execute: │
│ ───────────────────────────────────────────────── │
│ "analyze disk" analyze_disk.py │
│ "check disk space" analyze_disk.py --top 50 │
│ "what's using space" analyze_disk.py │
│ "disk usage" analyze_disk.py │
│ │
│ "clean temp files" clean_disk.py --temp --dry-run │
│ "preview cleanup" clean_disk.py --dry-run │
│ "remove junk files" clean_disk.py --dry-run │
│ │
│ "monitor disk" monitor_disk.py │
│ "check disk health" monitor_disk.py │
│ "disk space alert" monitor_disk.py │
│ │
└──────────────────────────────────────────────────────────────────────────────┘
┌─ CROSS-PLATFORM COMMANDS ──────────────────────────────────────────────────┐
│ │
│ Platform Python Command Check Command │
│ ──────────────────────────────────────────────────── │
│ Windows python python --version │
│ macOS python3 python3 --version │
│ Linux python3 python3 --version │
│ │
│ Universal: │
│ python_cmd = 'python' if os.name == 'nt' else 'python3' │
│ │
└──────────────────────────────────────────────────────────────────────────────┘
┌─ INSTALLATION LOCATIONS (ALL WORK) ────────────────────────────────────────┐
│ │
│ User Level (Recommended): │
│ ~/.skills/disk-cleaner/ # Unix-like (macOS, Linux) │
│ ~/agent-skills/disk-cleaner/ # Alternative │
│ C:\Users\You\skills\disk-cleaner\ # Windows │
│ │
│ Project Level: │
│ project/skills/disk-cleaner/ # Any project │
│ project/.skills/disk-cleaner/ # Hidden │
│ │
│ Global/System Level: │
│ /usr/local/share/skills/disk-cleaner/ # Linux (system-wide) │
│ C:\ProgramData\skills\disk-cleaner\ # Windows (system-wide) │
│ │
│ ANY location works! The skill includes intelligent auto-detection. │
│ │
└──────────────────────────────────────────────────────────────────────────────┘
┌─ AI IDE COMPATIBILITY ─────────────────────────────────────────────────────┐
│ │
│ ✅ Cursor - Extract to ~/.cursor/skills/ or project/skills/ │
│ ✅ Windsurf - Extract to ~/.windsurf/skills/ or project/skills/ │
│ ✅ Continue - Extract to ~/.continue/skills/ or project/skills/ │
│ ✅ Aider - Use via subprocess: !python skills/.../analyze_disk.py │
│ ✅ Claude Code - Extract to ~/.claude/skills/ or project/skills/ │
│ ✅ Any IDE - Works via subprocess, just extract and use │
│ │
│ NO IDE-specific configuration needed! │
│ │
└──────────────────────────────────────────────────────────────────────────────┘
┌─ SAFETY RULES (CRITICAL) ─────────────────────────────────────────────────┐
│ │
│ ⚠️ NEVER run clean_disk.py without --dry-run first │
│ ⚠️ ALWAYS preview before actual cleaning │
│ ⚠️ ALWAYS use absolute paths to skill package │
│ ⚠️ ALWAYS check subprocess returncode │
│ ⚠️ ALWAYS capture and show output to user │
│ ⚠️ ALWAYS handle exceptions gracefully │
│ │
└──────────────────────────────────────────────────────────────────────────────┘
┌─ COPY-PASTE UNIVERSAL TEMPLATE ───────────────────────────────────────────┐
│ │
│ import subprocess, os │
│ from pathlib import Path │
│ │
│ # 1. Detect Python │
│ python_cmd = 'python' if os.name == 'nt' else 'python3' │
│ result = subprocess.run([python_cmd, '--version'], │
│ capture_output=True, text=True) │
│ if result.returncode != 0: │
│ print("ERROR: Python required") │
│ return │
│ │
│ # 2. Find skill package │
│ skill_path = None │
│ for candidate in [ │
│ Path.cwd() / 'skills' / 'disk-cleaner', │
│ Path.home() / 'skills' / 'disk-cleaner', │
│ ]: │
│ if (candidate / 'scripts' / 'analyze_disk.py').exists(): │
│ skill_path = candidate │
│ break │
│ │
│ if not skill_path: │
│ print("ERROR: Skill not found") │
│ return │
│ │
│ # 3. Execute operation │
│ result = subprocess.run( │
│ [python_cmd, 'scripts/analyze_disk.py'], │
│ cwd=str(skill_path), │
│ capture_output=True, text=True │
│ ) │
│ │
│ print(result.stdout) │
│ │
└──────────────────────────────────────────────────────────────────────────────┘
┌─ ERROR HANDLING (UNIVERSAL) ───────────────────────────────────────────────┐
│ │
│ Python not found → Install: https://www.python.org/downloads/ │
│ Skill not found → Extract to: skills/disk-cleaner/ or │
│ ~/.skills/disk-cleaner/ │
│ Permission denied → Use appropriate permissions for your platform │
│ Timeout → Large directory scanning takes time │
│ Module error → Run: python scripts/check_skill.py │
│ │
└──────────────────────────────────────────────────────────────────────────────┘
╔══════════════════════════════════════════════════════════════════════════════╗
║ SUMMARY: Works EVERYWHERE - All platforms, All IDEs, All locations ║
║ Just Python 3.7+ required. Extract and use. No special setup needed. ║
╚══════════════════════════════════════════════════════════════════════════════╝
disk-cleaner.skill
PK ��h\:T Y AGENT_QUICK_REF.txt�\�n���~����� �jIw��N�/:˒J�I
����bL���Ҋ\q(��T��C���c�y�}��.)��)��(;�� ��~ ��ο����7 z4�?>�����!2��C�7�ZKӡǭ�KM�֚P�Vk��wǍ�!�ځ�k�������x�@�Q|�K#K ��D�4�5����l"�.��? ��r� ���ߟ����7 ~�̃�� ���F��'|�$��s�l�10D���_�s-(>{���
��V���o1:��H��L����N^Y���. ����B�r�wk�J�B�g�e�
���� u�Nw�f�/�m�ϛx�
�<��*|k���ޅs�RC����S6���R����Y XĶ��Ԥ&9��%�$�C��ܝ��9B��-�wy�3� �=�_Ua_�i� tNz/�-(v���A[?B=�jw{��<��
��s� �{�5(�E��Qs �m�Ҡ�)mT�m�8{��c�� ��wo�� ϧ�V �PvȐ�s<�P{zo���?=�ܷR9��2�������e�8�]�9c�>�o\_x�x�cRa
�.�����"�i-3�0����=�/�k<� � Q��t��WcF)4G����2�lJ�
!<^�TF�Q9`l�e�2�v��+i�H`�
D���c�<z�}8a��p�@���?fyŝ����m�}]��Fk ��
t�;��!FPl��^-^�:����f�6lr�� �G����������R��K 3褡��kܾ\7.��5G�-DǏ]���k�$&W�o$8j��\E,�� =r0Q�e��ʉ)#��(��,6%e�Y�eIL~i�6/, ?���-��^>0�P�=.��~j���So�C�� σ $�tʆ]�b�G�#R0��iu�,�1���*���}ǒ^����R0=q�������G0ϖ{��揺
����-�s�V5.�ŲNGT9I��P5�\gu�%��xJH�Ш�[� DG��p�0誈`�C��?�7R Љ+��;� ^�I�c�<Ÿ�`�R0�%���,D�a�=w��P9�{7&��}�w:�30� FPE ��+х_� �?U�i��
��~ yD���-��������Uᥦ7NB���H��քo�{�k��ё�����!m���XU�x2#T�c@��7J��>���H�D�9F����������"YtI�*;����Q�'0�xZ}� �r ��^��I�&6p�V��C��LD��)Qv��>n;��*h����=
� M�:�Me�a��z��u.�"��B�c �������GJH�a�4С�X�e6�� ��/E����{�VL�xh7����Ǵ�=����
� (Нe��;�k�9}���!m v�ܞ\�XO�f�x) ��A 4�b��441��1���RIB�F@wβuԾE�x�-;RH%�'IEJMv]Bo���8�|U;邏f<<}�q�l!hN#�[��v)/v1�+l�m���j � �cwW����VO�� �:�F�[�o�� �[T���k�*��~B_���3h�� ����o�� ��
� H�e+� �++�T@A��A��I�RI� ��˹�����r.�`W�T��srq���As 1�J�:�ɳ)O �j%K�7'�s���EG��}�����R@ �W���e*����8���>�L�O���@#�?����J���ĦL$�]4���mm]ow��I��L�Z��n-�ml',[W��j��; � G]��ȉL��ͳy������|�F���fc����C�%1���F0c��9a�8�^ܸ�a�M�t܇Qa�h�l���՚� �:.��BQ�ʼj�/�s�E��T} E��<�cR3�J"3(��m�~{[Uh�l�B1��3]jG�f"oC��9D�2�Jj��Z2��>q����(�k�S�@sQ����ZSAň����C�bT~o9��r�
/,Ӥ� S4�A
�y*�k���z̍�Z�9�خ��|@�����<�"�4��x�-)�(� �� 3�5"��P7��Z��ë4���}�
k�,ǰ}�r� �m[rY�[2�@�� �S@�'�њ��#T� �v�4��� �7� �
Cّ� �J0�,�&�P�� YV�%T�,�q�a�(��6Ii�ǘJix-� T� ���VW��FT�YY�8�r���h%)�6XަT][���"I
�3���[� ���dT�'J56�[mI�t'�o]���V��4 4R � ��4�|�qSC���7z�z�y���c������C��^j:��i<�*�]_D��j�43n��:N�Ӿ�(��� �Jf�&7�}Kιk��B�Y�&kM�l� �:�*)x[��c�`�U�%>pGl�J�}>Q�K�Ϧ�� �u4�-���v�V�'%����;'�N���"o��iG2���}S��j0��>�¯ʰ�"�q�z}�M����S�˗h-O
+�� w �_��~�u:���&3��Y&Ac/� �@�cc}�9�<��;�J�즛�u���Q���� ��*�SC]�S"s#� ������z�H��z�w�є\O Z��O M9�>�~zG4�Rz^�Z�MYsZ�DR�\�f�e0�S:Q���?C����&�Gx]��.n��Ik�X�;���
-�jEL�Xt���& *o\�һ�&_��g�v}6y��-؞5�2��-�6e3C�* ����r��9� ��/32�E8%auߩ��t��\��8 �fy���� ���j�i"��'�^h�%�ɸo�z�]��|sl�i��;��L�@���iI{ [y�@���2F���C�
�M/�)�0 ��g�PK ��h\9�-h � ENCODING_FIX_SUMMARY.md�X�O[�����0��"��C�n�V���"ZV%���F��7�7ƶ��
�?�c�"�y��&8�d�aC����ן��3�{}
a> Ϝǜלߙ{)�����˭�����$XW� ����[�Z���ٝ�Ѐ�%�OLX<�����^E��HV�Q��$ ��J�,����}a�:$�S� 2T��8 ���I6Fr3�|��6��8In��!N�qk�doN�չ�T��[\���i�?kĕ�1��'+���Zw� ��~�_ !]% ��蛇��H�G���;a���^ؕ�u���Çr=�ʽ�������0�G?�r�D���4����[f�]S��H�G����C`����b � �rp�r �KxwY�� ���[��g��]��sֈ�s���]�v��8&�-�ј�ݓ�Ȅ��!e}Ggț4?��북��q=�H^��{IH�jZ=]Ǎ��'��&t�X���I5��g4��˄�i��< &��C�5�ϩ���Ř����<je�dv�Q����~<n������Eb �6� �� �l~�����M��;��.��cO\.��籸 n,�J��
8���K�OIb��'\��ETMP�� ���k���1"� z���|a���ٚ&�-G��:����Z����;� � F�0�����3�w�������J�4��;��z聶3�y�b�����%v�w����чbk}�o�> �Zl��:=X<�\oέ7
1���7:48<l��!��K��x6/�fx���nFY*��o&�f��-�A�u 2����)<��c=m4 ��ԓ ���[�z�5c �zT�� � ���JSr����!���k5e�N�#d��H��&�B�(�(I�q"�S�R'�m���'��'�
Kz�! ]V %hm��|2� 㿅K����]� E�� ��aF�V�Y]n��lB������CO�ɋ�Nt�y%��i�vw]�b��Nm��Z�Y<�; �����i����<��?xl�%N���
h��ϋW�V�o�䞞�q��)�Xv����q�#M�D�jdϖ��4�"�R��j�������|586px���_��Ӝ�pĴ��b��u%����� ��� 1�� ��!u���rjeI-�@uj(��J>�{�볹��1I`#�'�c�a��j
"�E�Q� Jd:��]]m*Ӈ���:@�ܜ��5('�����~���Z�<���b���,~�� ���\k'�VB ��MVK�����'�s� ��*��S ezUww=�r&��l�����ѷ�@�����g?�80��
�Z=v��{� ������\��>��^��� �ez��C���v���xl�� O�=�� @����x/��0^�.alE���N�q��/�����L�FA'7�>
\�����1 6����?)��M�D�p%' t(pQu[��AQ�s �����wx~��X��Iu�����P3@���H�� �i��*:9D�)�z7�t�4%1(��Y�4G� �Djt4�Z��h ��2 ��LWH��P���a}N7�wg��4%P��L�u�&�M�Vu� ���FVz
�4 ���dwS��jaU�I��`F�l�R�m�f'�� 3ml�4m��!�
�b�=$��v%ڰ��_�r��0�]Bw��I!^б��:
��`&
�k��坨
���14�K'o�����Fj��;�v�V��m� ���^27�l+�Vh�u�|x�/�^�1��S��cFs��D���t̶�"��;�ʣ�m�ǕQTb�'9��$�n�+:�b�C�[�� <�H��� F��=&" Z�e�N��t ^��Fѽ�$S �� �z���O�?Ǡ4�'�Z�S N����5 ��9Q:�����mj
��s�[68f"�1�Ʈ �2&Qn�}�� ����Mo/�P���$/^]?�r9�T�*���h8�/L�7��%�5�ɀ�<xz�ׂp+wH���5�\�JW��Z�δ�y5f�2��7߈�|x����c5�� A.��9��SE��F�?w�uL��Ղ�r�m��ٶ�W&��8�8~�_L �� ���V�<� ȇm��}��N �Pv}���TwO����tq�� �/X����?�-�Q� ��ڣ .�s�hcƹGr���jq�� i f5��w��/�O��Or��s;�|�3�` �I�z�����`���<�{=09,V��~���t�L��}Z`�yeg�� �%���
��|庈�� �#x����71�<7J�o�����Q �ٻ��Rf��h�8��#
�氎�V�Ã�d�}�y� w�� Z�a�d�P����G��3�' �O1�I �� �y`;��O�3�M��E��-A��E��~�g�s �p:�#D�'�Rc)*�=H9��� �PK ��h\��#{
.! FIXES.md�Y{SSI��*�C/��5��Yk�*�
�Xq�Dw�V�$� f I�ޛU��� �gx8�P@A��Yy�.N�ޛ��������}$�SRS#t��}�<��S�bH�G�R "�DN}4�$ �;JӕQ-���?)/+/;u����d�\�k�
����2��-,�Ԝ'g�Μ�ԝ��}�v��Am�-_��y�H��r5� ~�%z����$ц��P~&�1K������'� ��m�s�r;���Q�D�S�k/�֗�����*]���Z����H�1;�"#�6>n m���e ���̒�nJ�x�/�� �o-QI~�-�У>��q�1���WhO��m�
��g�
�C�d���6�M�_I�����{�r�/�
��-킾��"�_����X�z7�GX���ԗz�Y���M��
�~:�h���
Fe������($���*�*��������5��������p���ԓ�r\*/� ��J�9g�,G��'�\
���S�ó��f3('��a�w��A�}:8O���_�
�}w�QUQ�@��}s���(�Һ1��k/�o#��F��4�}�m���%:�I�n� �w���'r��te��ڛ:�ﭡv�P�Śצ7 ��'�d\�\�.�M-+���pS��'$G#]RD=-�}63�����0I�x0�9M��;�
�(�A�i˺�y��⍖��������Hy1$KA5*w��l��=�#LȂ팗��t� �ԳӠ+K��H{��B��p�hckt�=p�`�=�W����1D�ϩ�Ά6=`Ŗ�h����/�^����F$��KM���/ �?�$����H}=�� ��=S!��v�=WA?�ʠ����rH�䪊��������"�މwtH�iR� Պj<��x�ʎ�sta=�3�|��&�3�Mf�T$9�1��}�ͼǧ�B����3�6BS��`�!
:/�ߟ_�-��Gn\��
��dD�ӥR_)K���T�'F"�$��@lr�A��^3��C4��jCO��& 8Ц6?fS�t�y>�@�~A��K $ ����_0Q�a��Z�GD[P펱 bK���q���{� ��g�x�$��[�j,�6^�:�������i�6� �z�K��� c`p�qҙ��$朡Hg}%��J��K��1�� +�e��9��Q����C tH�� �� ��3�25b����(�zq ��N�9v�H}!���MC[cs3A��!v��4���w�{`7�t���;K
--/�y!f����� ! �[��Z�r Y}��lɉy�Y �h�/��tJ��:6?a�QjYV���\�'�|� L��=����H�#o�7#�ф��:&IAa��I%1�����˻p-���3��s��u� /�m�1�ް��t�
>Ӥ.�,@Sw�]�7��p�P�FHI�{�˂1� �tfKS��)#���$��䳝[�P ��������J�[8�(�������X�* O���P������>Q���X� �!��^0��iy"��e苾�Έ mL �T=�� 𐑂9�d)�$��蘭�E��w"��{+s���4�4�B�#sq���Ԟ2p��|jd2��e�'#�3�/x�er�8����"�9���3V!:;�4f���D&;L��rb
��H��77Q�FfX�� ���ԆW��a�$����'��� M��O���]-��>ܣH{���"E�|�.�������J�� ����SC�H |�*��� 6�� �X@�a�١@g$�H&mG �˒E¸�Ţ�3k�E�}4"�4���*Mn�Y!����)v�2�-�B�Y�*���&�4�tg�jOFs �;�-g�;��1�tdc�� x�̔�M{֗:����7� s�$^1���M9� �� ��J���,��O���yh+džD�)T��3�>f{
~ !��_�H�;;x��ޢz�cJ`!3݀�cP��>+��xN���#�t
���45�)}bP��ȵ���W��FsZ��O����H[�ؿ'zD:��?Qb�+83tI Y"�\�s��9x
`{M�<�y�������X��W���Ķ� ��W��X7ǭ�����C\Qx
�g3�WD[H���.��8��Hz�L����WE� ��0��a2� #{��
[A�?z�O,�l�-5@Gg�Lm��[Z�]�v<L(����f��*m��������
n6xr敾�V0^&�oB��Q�*��Z� ��� L��\�APjCk �0�G/lX|H��?I���0At`�H�
+��)����Ν��(����)J\��W���X�b}�{V/�/��n~�<���t����0��}���>Y��]��3d��wl�ѽW��ݾv�gw
�f�:� <y�e�����F:B�N���IMt�u ]3�$�̈́"��:7S�@W� ��6����eg�1/V�9tp�787�@�D/�ɘLrY�&��� �5}f���o�|�h� ���=���U�!&P������ �F f�6'
_ב*6�@���D�����_��C�7G�_vV���\���o;A�X�C sɆq�%[%vP!�K���J}<�p�RE�$����G�ՃE�� O�� m��Q`AcN�q��=E�C\m�1'~gM��ŝ��PXj,4p��eT�ndnl�? s��pw��x�J��)�e �ḑ���/ *�ZG�����U�s����X�`�"�o��C���<$�-~1�^��w����@��?������� �${X�/��;�* g����̙.��B{h�d�p�0�r� �;8v �Ze���wNc��F8��i=�WDw��\�V�BǠ�/0"�������v�b�g!�h��;l
�o��;#��AA5�{����������wlĥa �&��ሯn�5]�z��RsK�W�����ۥ[8|�e?��_�v��m�-�H����V�Ԗ ��Q�9�A�gJQ�P�=�NN<�}�d���e߰ ɢ
K]��9�ĭ��o��=r<R��Ԗ�h�N)����7v����6�
`��>1��,�
����= �s"�Y3��c�+ /��l^�����(� �ѫn" ��3*O��c�bN�+= 6� J5 wJ8���z�,/�}�15.K�(��׳���Τ5�����l���3����7:m~�}��|M��E�]�5����� �{���Q��7s[Ċ Nar; mc��ʚ�����6�0����m}cZ�Zep�7�� �b��ys{+���iv�N<� j�ᷓ�Cz�.קR�g/���.;= ��/��)ס�U
(-�(�b� �5�@:�8�yL7fi�: �מOXi깨 t|4�����^�|�Q
��/��p��)��O�^L[�m�̘��*=�a���.�[��o���t��w�*8�;� ��O��f��t�ټ�������{!�8�ĕU�� �hG ۤ �O��:*�>��=�[SÇD�e�PK h�h\���\
INSTALL.md�Y[SG~����eW� I`��P��Đ-�N��ڇx i ��V3�c\���$�6a���l��cb��q�=�'���e����TTԌ��s������N�"��~t�+����H,d��d��D��a�x�T<�g���8�'.^D��lT���d(K�l�� O���ݦ�v��67W���h��~�}����f��*��'h�U�k�#��xT� ��q�i����~R��\���}]�<@ �[|�'\����#cc��������QY�T�ry�ı�����A���@B�Т? җHt�$MM��P�������ǟ�RaO� &ˡ|�A�8>�Zmm��
��F��ԑ\X� c���8��J�=�|C��K�7���� �Y�/$�����N����*���K��ԦP� ���w�} ���"#�V/f��
�(V^��P���3���'2�%�CB�$5�5� +����<����,��Uߞ0����$�%��r*T~6�� 4�|�T�+�}j�>_��uRd���������#}i�L������q!B�����q!*����0�E�F�]헽^'��c�.���"a)wX7�� t2w�9pd�T\�Gy��K\�;.,66 �h ?��q~t�v筛�n|�u��v7�Իlz��u��Ί<������!� \�a�s8�<r��<p��18�U�S���g�;���!�U�����D(��� Z�q�ub|�ĭ�D'pl�:% �q�}0 ��� Z]����ӀlA���i^���s��AdSj����a-���]*��/'��P�V �F6F�w��:��!���G0 Y���et�È�V䠦:�}������+�@��Ԋ�v� V��0� ���������Тq4ގ�8�46�x���@H�ʢ���KŔ��\1��f�
dy�l�J�I�-��z�(�t��dZ4�����>ad�yԍBl�H*����t\��=NdK�u�� �r<��
[��ϕŐ��Z ���1�<-���a9�w"x� \���x��+�O�Nl����>��i �=�����Y4�����Yr�f�]�h�{S �Ork���,������ ��%I���f9} '� j�@�* r�߷o|��j�P�?�m��� А"�f��ֵ�E&&F����A6�/C�s��q��'{%�W�����>t!��l���\F �<C���zkFcCSӻ���\�"=�o���y�k����DZ4>
�t���<ʠM�; Rc3�V��O��B��8m� ,����2��'a��L�{�-��`<�(#�l�)�I>�O���d5� 1o�W� ��=m������&��|�y_6Ŀ�3\�����O~o��Qїͧ�Q��� �z��C���U�%����Nua!�C =����N�� �e-��Bp(=���S"�M@t#}��i��� �����}�pW�� p�V���}N� �4���/���q� ˋ�`b=���+�@x�~MR���fF�|�C�N[�W� W;NL�������������;X���/�s�p���k����tN�iO5����WX= �g��9�T�R�*N���,G���#�8h��_���� ��!r( ��+����}>R�*>����.#������ �C��p�����Ż�He��/�t��yFG�<��Ҁn.뺨��b����9`]u��^�Z�Ȩ�kNx�K6h�٠F_��g��ji��"��'F6�y���d9U �_Nf��� !��$TDdnϔ<��S�hN-1�c�=���j�+h����d M�"�Lgi � �hF��}����ί������͝}�):��X��R�fM�� ��y0�T:zJbk&�Z��G�R.^*,��j��� >����P��~W�����ԧWq�з��um .���*X��8n����H��z�2Ⱦ z�49�W�P��r �
�#��[5�x� ��4��v�$��b��/JD1k��Ѻv��6_~��ۥҧ���z����r �=.
�n��A���{T���N�zȞ�dpvW0H�}�T��Z<R|W�>x�T�����}T)< З��_�V���~~�Ȭ�� X�qaRPo��F��V��mҤ�I�&�N���*�b���( �x�̋��j� Cy'k�Yx� �xF���]�.��9��B� �6�1_l�]� ���/�m�4�"됶�!-Ͷ�6� � �c �fki���.������oh�X��"s��b�L=��W`DŽ+ �W��:��zr ����.v�;%������ ��|�]��Yԣ�*[��D�1�^�*( a������R~�Z����Uc��Z#�����3�d�Z
B���
��'����!�R�m�������G���'wåޞ�K�6���K�X7r���[����}Q% ��q�M�k���O�TP���HXRA�f�� DW �Z�$&������r���ھ8�x�f�JX�*�{�t�ܔ��� v�?�� @-�P�W��G�˒�C~�Y�i��0�_C�M���z���a^�ɭ�4-� -�ۥ|�� -�xM���bj� ����n���Ӫ5�}�0����l��l���k]ׯ�} T�(�=�03��s�ԭί;��k�Z)�u
!�9a^iW�xȳ����h0�G8b�H����'�$�i9y�f���*XOe��GDή�N��V<�D^,�G��f��8�|� 5��^���8�݀
s�~ O�]�~W�d��a��v�ي��$
���rj���sv�SUm�L�uS�j ��Ϡ�n ���N� ����^�6Ñ�)���r��"Ն�i�Y��K��f凌�8L � �ڦ�#A�K�|�� x���C�Q s�"ݓ@QI�]N ��������̋ D P�_-J�8;�V�9;��� �ߵ���8C���.�p
"�ӫ�5�U�6�6o�+� �}�?|[��^`_������� ���Qbל6½a��B�-H����4��(�s~s2%�4e�q'��T+>dS����q�]F��>N��\�^���c9er}�7Dne]O ���c�P��>��� z���3�� �*P��
A Ъ8?fĆ-�,!x2��$�^~V�m�^�/����� Zah�w]?��[������H�^o�ٱt��I|� A��X{\���ѻ�Ɔ�PK ��h\�= ~� - NO_PYTHON_GUIDE.md�X[O[�~G�?�7W�IHU���)i�J3�tڪMU ��6C*E��l�wb Ƅ��f ��/��}�y"?�k���9��LE�>^{�oݿ}���|�HXt�}(�\�|���P`���`�rUW����r��am�q[�wvtvtu�����B�^��֧�����; ��cl� �s�\R ��K��RL{1�DY��%3`�g�F����m=�����R C���M.������`O+�eDi\^C���Jm_��h�����m6�r�
9�4Q�YZJ�H��Yb_i�,:��Q�WQ����0�ы}�P��4_U a�߆G}�� ��,z�]ͅ�R�&W�����T* Z�!5;�� ��J��z鶞
�Ƃ� ���{Lȸ��=�xt$��=�:}I�kzmV�}�H�Y"�/���5���_�_9���ܾ- M�"l���Bjq�V�R�&�s[I�}k�V*�<���p٦�U}�G��ϴ
�� ����8~? yGF� �X� %��Z�������!�2ğ��r��
����u���?�`�}�D�D1n����? ���_z0Ͷsjn�FOI�5F�PXZ��m��fh �s�C|$r'
�,�6(}$�bxd$��7 |� �{G��VT����P������?�0$� k�w�����, a�<
����'�it�^|0:#��%�2��W=��6Ei���(5�Cm,b5� %
�f��z� !��t��vI�ߓ�'=F6<ߟ�/�G'^Y�a�" �
Mx�����18� �X�L���!��==B5����z�~��/��o�����Ύ6��H�L߇��DsE�zm���;z.l�����#~��X&�1��� t���~������8� ��2� :�֠KW��)�a�( �W�;f��ڼR�$2 `ad�� ۩+��L`�H
@|����~ �_��F�C�93.~m���M@���g\��WkQ��lB7�O����w��s�h��J ��; Ȧ��N�xn|~.�n���>]�k��M�H����}� �+���g�@};�nn����9�9�1�a���-e�~� `=(�9�.$ʡ�/ ��6���F �T����l{�a%���v*��]�
1մ�#/�~�Ӻr�1ٌ�%�����Gh}���&C��lAU8����Xc~@�ȣ��r�@˗ZyK�{g �%M�G �����
/�c "\� ?�����>mH�����w������9͢�:mn�_���^��]�3�����gp�Y�����9��$�� . JkE�} ��:;�$ lB�4 �C�=ݻ�'�ȴ�"f�b4�.so��,/���Nn%� ���<zr�'fc@6 ����Bd'��ў1粶�'?�i=t]#�6��$CX���� ��� ͤ�0�Ly ��c��95x��(W�l�\+ ��9�Sb �ڈ�}��1�ճ�Z��N� ;���T� [�d�����Ta�i�
�v��@"}W1�]Rw���͌U�*53g2$nv���|�f
:H�g�JI� �R` o��6 ډ�ê��hO6�t���U>@L�r�6J�=�(f��NȔ ֣�2=��3��� �rUS ��ìW* 0�:��Yf���J@� Z�W�
,���W(1� z��"#�MWp����$08�l�����d��Š �q��}C\C�=�Aa�r�%
�� ���<� �^�S0�7�����r��*h�Ox�^���qY�0�Yy�?m��k�+��֫�� � �� �����\���<�坻*����i�x�$v01��R�krs���'h���8L 3uIf!B-�!~hW3,�kՋ%qH�i� Wؼo& �8C���{Ju� �f���jJcՄg͠�� ��*U��g ���hi�( �1/���
˲
�=ԓ�<-�_n|;1�P�V��y ���e��1M�c��TI�2:m��fk�ZE;����
�����CXo|G����a���t>�+I��o ���÷�|��)��|�aUr�2��Mm�P�r]b+�rp�)([J��<ELx��XV� `(g�/@?.+<�M��M\ ��Y�F?�[�l�� ��K1�֥�,� �j�ǚ�
m����y8�k I+�hE`� 3��w�����J��+�*֊�:z�-���.�؊���w�Vd�?��v�tw�k�'���B��z�E��o�h|����-�'�c}%���=��8M��J�m�R�� (k�:h���`���&xH�Z����a�cٓ����/�����?=\d
�+X� �
a3:�Q�j��u�Wc\W��X�N ������"+#�Y%��� �-����x��DOW����Y�0��{ ��m�Ԓ�d*%�2���%�k�~��]V����y_r��5 ��ہ���;Z~_�Z�U$|���u��$t}�fC�sɒ<�a� a3�- >��5�y��^�PK ��h\@,�& � PROGRESSIVE_SCAN_SUMMARY.md�Y[S�~���p
R��"!��MT���Nm�)Im�R)��1(�jf�]�zS�6H�@Zs5h��\d;H$�����D������9=#� �,q*=��\��t���Q7a�l�|�V3l�
�d��V��)qZH��w���- �DE�,vvtvtw��=�;�h�OpNv����7��V#�dϏY~D����}�"�z�Z���d����t�Ȩ?�?�V���1YR�П%w��(a���d0�܇Q�r)B�(�A� ���E���S:=U� j�Um�@O���z6�'�ڙ�Sn�xR/l�a��Qc� ����}�-�Y�N���u�V��=���U�������\�l�&�B���蟔h����B��đ{!���#j��|6�+o�yV �����3���\0$+0qãoᒔ��$�(R
y �ۃӒ��&�� �oI_� �=� � �����9?�� {�lX~ׯ�C�,�{_Mqo���tv� ���Qr(�*���� ��� ���*�K��#۴�j�m�(q����|�G~6��@p 0@l�|���'�2��:GI�t�V�֮��k<���4��� X ���d�rĖϲ4u$f��A�y�e��ξ�rR�X�:
� ���??�o\z�A�MjZx=ay��J3g�������Z���~�tN���ͬ��K#I�3[9�/6-��˄�Fb��}B �z�El� ͦ p��QY�vh�
� �~@O���E�ĉqW=����Q4���BS^3�iW��"��Ȑ���Sof���y��3����km�q�C!aC�
�C�氒m-�^g�wk�9�Ӥ��3�Nse��H�>B3�0��Ϲ�/o
G[��m�c ���|��Lӵ
�$�v0�T(�A j��N�>»t����́:Ï�YH��8W�7�������FBy��P�N�/|m���P�M����l!_��~D������oԹ�V����g�*� �s�s����Ö �[�,���督xK|�!� ҩ�z���aṑx��G�!�r���/�<r��h� ��� i�=b������/FH�� {l �.��6��M35M.��"��/ �̊1��"���JI.�/C(����4��� Rq�0���̬��
�ʃ9��(1�U�D}o�� �#��O�l��Hz��b�K��1�ɏ���X�+��N� ��W8d��8F90a� ���h ��֯���~� o^���A�Ѷ�ƊM@4@}Cce�br
����vv pSn�d)�F��2E�X�ʒ��1�,=I IF0I �c�52�:�����d� �`�rkB[�b�,}�GT71����=�;��,E�����y���`$+��k�s�:w�c MOу5m����5�5߉di�÷��q�z�Q%bI�.�xC�FR�t�(d4-� �/Z��7��Zi�����dKF�2�n�v����|c/eX+�*�\d�M��*��,�Y��(��b� q� �����y�l�N��6��_��5!x�k����LS�5v�JH��W'[ma�!��S �����Z%՜�|�ӁZ�u����1�f�M�=s�z�
�e/�2�1q ��|�=H��94vO��2M�����F�ɳo����+SQd!����*� 6m���� &�:��ѵ���
��0�؏�-�oP�/Ơ���N���fWy�`?�Y�}gGP�G��
v��������>�S��� E��Z����=B�M+��.��:�� �opN�d�(�p� ?� �8p��Ѓ�����K��2��yb����%%�up�G�
��~�˥��Ǽ� S�4����:�{9.�fU雋c�w�z����^㴡�XTV �>���a1�G�AŁgw+jd`�#֜�~�c���i��pbOo������6_0��.��^aPt ��u}���:[������Rc�,��"��^< ��n'��E��N�6_�/�!�,D
6u)����=$}�-�]�� �X�5lf��}q��\�m�j"U��lex�cN�vrM)�q�`-�f\�0]n`��������� �*����D23�Oȅ��CgI ����SYm��%&��e��.���[h��Xw�j��fk ,��L�H�Dh.�l� t��b�P �)!�V��U�����r���~��'oi� ����u#��ܤ~%ɶ_�Jhs�t����� ����vZЛ������YB璥�?$[��ۄ��xǙ)
�3_A�H�:��;J ��M��-@.���� .��b8�Vɘ�=F��I�H��22�& ���� z>�0�a1ZO��+x 2�Ze��2UW-n���T/�/���X���ѳ)A��
PK ��h\�;V�| ]
README.txt�SMO�@�G�Xq�lӢ�R�@%�H P�K$b Wqql�^J�CE C��R�$4 ᛤ�@�M&�k�� �� (�x�y��
�Aɘ��+��ʬ5�BY3B!���־�sW�l�
=f:Yĵ�S�,�[j7~X�}���2'��),�.�XG��p0 `�+I��3F�z_�����< � �FYA��b�kgD�F�j��;l�Fƹ��L�s� �; G1� ��\�OX�39k�D��3�[ T�Ӿ��[7�s�ʊ�(')�e��Ci<LpP��1����C{=�r-�,��:�O��&���Οb�7���� U��K48^���{q�%b�T�<`W� GGu��(@��?@P���>OƽJ|i��ET�G�k�C�����J涙q. 2����� o���y����z�ѧ�ƹ=e��I��"_�� R E��+T/���|늆bRs��_�odR���*t1tq��T �z����wgx($�SR����e���w X�+8W��u{o�
��9\.��%����m3kݬ[�YZ�.�y�љT����$z��IU��y��&2RRSu�G���m ���b�(m��>{�����]�����A�}�e}Ϲe�x�
�]�>��/��!)������ PK ��h\3w�� )
skill.jsonU��j�0���âsl �4�М� �!m�%���*iC������7�����rzE5��$��,� �:d�@�.Ѷ>��.[���h���|��jg {�*,:& R0H�Y����t ����tY�ś���F�(��O�"�@�]vd��
t��Į�� �8{���y�-$M��v�idžQG����}���j��m7���u? �����,� PK ��h\ ��A, �� SKILL.md�}]sɑ�;~E��X ��H�E�� � � 8��6�&�#��n��Gr�n�:��o���������}��3��'\~TUWu7H�� �����]�U���_��U�T
�3ukb�E�+����nX��(�f��5���(��&N|�S*)��3r���sw�����`�ڋť_Ϗ���;���z�pXU�Z?;j�Z�Π_���E�������������E�{pX ����ۃ�5�"_G ���/�m�n�"Ql��(��珣yxV���=�E���1q�cޏ�����8ܯv���J��l ��?��jĉ��_�I0����8��Τ,fa�;��"�<rC1q߸����w+�ngPowZ͚�b�� Q�L&�wݱ;.���zY�9
�8�CgV�[/�n�>8� /ŭ�8�u��G �"��z�����������Lg�E%�P ��y�F��fF*`��� �]���,��J������{0Z�� ���aM��qP�1�
��� �(p��p��7�a�%����E��%��u���B�hu�&u�_yG�7] ��� � �(�BP��D�]��t��vC ��}@��� � R���k�� o��;�P�qIt��o5
lmW _�3'�a��~����^X,��(�G�0ĩ��>��lM��VE�����{���}�3���If �%J���x
k^o>�Ȍ��nw\b ��>L�s�Q�$.�"iNO��`zr�bp���Ć86ן�9�k?g��C,���(~�R� C(��&��s�'�XEHu�+v��؛{���P��(��������?D����qq��
`Hع�`⍮�ت�}�4�;�g�51�C�l����R�"��;-�����`��ٔ���:t{�o#*Z�7��J��8�pB� F ������W���'e���y������� ?��[�t�|� ��O ����G��� �~�M����9Up����i]������`��$�(����6��� ��yg��H��
g<f<а��K����u^��ͳ��$��)� E>�+� ��}��D��B5`���x�ϺG�Mc./\_�.�$M�|8��] ���v�lȎO����9�� � �`��u0ř�; � "ύj O~��<��|4��Q2(0:sC^jeq����VO$+�
Tn�ab�]Ǜ���a B�.Rվ�_���O��� q b]�U�(�� � ��A�ĀZ�ǵ���?��,1V�N8����������cxI<+�#�L�D3 P��� �5��K^c-���@
�5�G�p�ν�#T;d������� �p'�)�Sx�#� �$�x� (��� �xF7�Q����U%�(9�f���9@��*"M��7P~ �CP�QO��tꄞ�K~�B�K�_(4�q����
�*��4W���E��[�TU�_��T#��������Pݐ��#��� 9 oH�J��=�{0��[�v�lO�{D��pk<������H����pb�g�d�أ�4�O��0��/�|��eY�;^27��O�8�0��8����+��.���aw��?"�R����0�9��_�"�yT�q�'���" ���^899)�-�Z$�Q� ���A��U��k��fyss�ԄT:��)" D�C /�}1�Ҍ� `[)@��\? �<�pl��(d���T��֠��G����u��M1x���v�?xPb�Or��k��U߯Y��bM�xP�4�n�%��}R5P �P���y*��� �f��^[���ɴ��"� �/\�x��೫a�;����1h4 YH�d�БV�4�>��X ���O !��v��H���0���Hn]��%�{�3�`A�qǧ�
�:wS�g�j`f �GznT�6,�0���k6�pp� ���mC�|�, E��ZA�+\Y�&u�X@�+u]�ĦY�@gQ E> lUQk�\�ㅁOF���)QP �f��>l��Vo���� ���L�bC��~ ��>cu|��L~r-ئ�h���tT
gJ�,�48ߋ�4�l��
�� �K+�s�yr]� &�XJ��B� �Xe�����������f�oőf�
K�ңG��-U"�{ت,�q ;�e0�G�~�ܟ_�"��HѦ�)�ʒ���)��>��x/m�&���.���;�3� �q�9&� �:��բ h�`B_�(+�#�yT�|���U)JaI�� Щ=MmQ��fR�dEZ��P:Aò�CV�}5l Q�J+����
��9��\�2F� L@�f�� ���M�}�"%��8ٌu-� ` dJb�p�Dt
�/�kX�q �� �c\ƚGEW<��9��E�m잇�Xrs_�Ī"���.j0ϓ����XT�� �L��q%n%+���v���
�EP���?j��)y�@�b��� (� Y��IlG'�%�gM��!@�a �Ty���@v{�K�A��h�?�i ���:2�`)�4oUt0�c���L�+�|�~+1��K@�i ד�s ��� �=�xI�(H`*�pO�� _h> Z;�IH� �?��`6�����҈�
�L�ja����k���.�� �Tتh
�_�Cd���H$���, 2�y�I,<2���p gIa��"�Z�U���M�ҫ�� �2�ݝ�?c��\xL�-&#KkV�n��,G%�� P�m���L,|��趛�خ.�Uj�'��k�����~�'컚��l�A�Z�&����}u:V��NJ�9 ~�
v�n< �Z���*��]̰߭s�{����᯼��v�?�+��X�L ��t��/Ϻ����V��� �4�vH<(�X�C%Ó:D��tpP��ڹt3vc b\PV������sPh��E��E^\8��P �[P�D�a��'��h��l�U2�?)0+�kF��$��4~���=�x�j<g�` p7�L�˒���d�վ����9��Z�l�WL�A�Pl�,�b,au�G�\����d�S����ݮ���5�j����JJ�~�Un��Q�*�xb�T�8 N �$+�h�1�/"�W�k�y��I�'5X����>ʍ{5c�K��.�iM�H�J��Ȝ��hұ斺�O@I�.5g'���z]�`�3i��sH�مsW�F�;�f���^n�������O���{x!�K�:U���O��{j!�N�:=B! ��=Co_�F�H!<G߃d���K�ضvI/��Eeϊ�nO��{{-�Q������;�IQ �� �o:c `�\"����Q?Z��*q� �4����B-�P �X��(ѽ@'�y�*QI��Y��x>����!��T�F n�|�l�صc��D�u)�cg��sAn E�S� �;
LCb�xW2,�RfWY�U*80������ݐ��A������X*����t�c��u0���b�O�I>
UI�b�{p ���J��϶67�����R4�)�s`��!߯oj(���<,Q�c�+�u�z�*z�C�� �B�D�QE��`2Wj��
9 W�t]�� ��y���������B� �y��2����uX��}O����W� ���h͜|E�Y��0 }QH���:�%E�����@&u�:�rC��/�����.�
��$G�Wj����U6>bχ��e���G�|yÙ�Tms��I_�C �,AT ީ.�^
h #/"�=8��n��U��Ôt��T$�� \��Wn�b,���X� �[�gD�Z��r�^��' ��lm�z�� V���/
@E���l�q�Я�$p�Q��Q��q���U թ�(�� z���[�$� ��e��U�6~*�7k�{R(v�:vׄX�EO��r�w�`�Q
���wL�h�L^ &r�iS�O�S��Z�� �Q�#,��^�Z����J4s�a�������Y�S窢�mo�5"7�Q$K�8sg�9pQ2�wpoϽ^ ��#�u���58����ځt�"�z��3�3�&ȰeK��$r~r��^��%Q)Y��wn/w($~�� ��5�\qՠ�p��{g{�Ą���ҧB��1�����,չ�I��(��[+�J�,��\�-Ͱht�d��A�B�X:N>/�39���7Fc�P�'�����1�ߤ�����h�:z�k�����G��� G� 1�� Ⱥ[ԂY�v�j �*�w�t���*&?�U67 &<j����$,,!m���F���"-�{�)\�C���l5�}���V����6���w_�fX�-%��z��JM���"�^�
`z��W� ?|�����߷Ѓ����k%��^ JS�%�#Y�ßu�������S"�6�rf��ÿ�< ��ĉU� �>,J��#0�P�7�;U�� loV@���
'�n ��m{� ,�{I<�4*\P4���N��Ȑ��b
&$Ⱦ��@>� �3� ��~�G6��~L3��l�b�骺9��DN�:X��퓴�#� )�VL���{e���!�>;�xm�g�� kDa}c? �)��V'��aub�}t��Z���j�!���e5τ�\��g ��ҲvH-�3��cD 9��Ѕ/��d���ǩ�f&��]����bb��� �1���i�N�؊�8�K�:B���̍@�K& ����=|Y9Ds � sp$Rf���4c���v1�N�^8m
H��
V�����v��p4 �(�+Q��o���0�5iT(5ف ���SX�b��q�*S��o�e��`a���s.���6Ws\��!Q�@� h<To�L����7�;�T �%tS$`j�EH�l�[�,V��;+�a`�JAvЖ�7���n~�Z�,%����|fM�-@�\��pA��]cN&pY�z�2������I���n�ц���%��ٱ�]�9���;bs�dI���)���|��o7�,~U�ޖ?U������f� ��xl�"���&��+֪�g�oZ)Y���ڌ g/� ����Bǃ;u�����D"3)� d�!P�u��Jɘ�[��m�YH��v�Ix���d3o9$}���1}����T�:��ܱ.$% /lCin&=Iy. ��/�� k�- )���;Y�bIǑ�=�D'>�kK� u~?���*�O���T2ڬ�7���Ū���RM?��-v��m�l����f���������V��dN"6�04�y�<�5y����@]���Z@-��b�OI�A�-����-�0��\�n�Q��K��%Ko\SwM���4��C�D�UY�nP��v�A�?�?o����ϻ�f������Y��ڀ��HA�=�D���a�"��!
� #�)'J�9�;F�V��}W��b�.oW���,���P�<I��'Y�s�����;ך_��+"݈�ł!�Jmm�k�%�F2��{�[���?q+�~�vX��4��mh�1 tM�T��h8!h�oEߋ缡�V�zˁ�o�TF�����{�~�/��8��MD
o��~+�"��R����Al���`���O�7���ʬê��۶\&X� �=�تky>�voqY H��a��D��� Ԡ�e��]��S
�� ��x\f�n(��1w��pK�����\�B�i�c��_���� �N U�+4��hN����X��6T3���bgb����=2�=��1-�3r_�x��~TG N��#���фωvL�UE��M���*�L(h���b9\Y�G� 8��Cm=i[�I8� �0q�#
������P� �&��Pu)����ݮ� �?�u�b���" ��=Kz"��J�V�0(�;ݠ��j�;���zc�np�9����x�y}=���|�"$*�
� "�IV2�m��g�a9��u$VBY�XU�>�@?{�Ui��ӦP}b� :�Hѻ���� �R|����n��
쥅�z6�U|�"�1�+9a�� 9*ct�T�uU�$��� �گU �2ި�:b�E�_�|1�'q4 �ZF��z?\��:ŭ|B�=�
��ur�BF��X':�q�{WwU��}T����{��\�s�R?oP$a1� ��% ϲ4L���KP,n'��E�'�� ��[�&�f4�=������qdɅa�WE�V�hВ��C�Z�B�n�
��Zw��L��H�$���M�S�EI?,���$]�&.�x�66.//��T5�7`%��h۰+�]�����t�� ���!)��uTu�������x�Jk�c<��&�ޙ&��ё7Wf'���&�[�\W�,$���E�~t�h� RR���mpP��S��D ���@ᘣ�a�A��r���l�4��ـ��pT D���*�Y�
�A�Q�Ǫ�L ��|A��9tP���Q ����� +rd�� d�c��� .A���G�4���b�x�GҲ(��H=�V$�i�3IA+"������� ���<��-1ƍ��d�+꾒OL�T<���6_ +X���S2���� x��#
��Q��������
�f��Z9��gc���եK�Ӽ �e� k/��<��e�aHo
1
. ���V���*���
����dnL��B�]~ ���E�q"�T,
�C�e �z��~�@�QI�tGl���y(D˵,��"Hz%)��&I��U�%P��.�4
��lvu;�+� �!k"ͻ���� ���;��0���Ci��N�NS��Y �QUZ�YŞ��DA)�(�Т�Q�i��&�dq�PV�/�Y�=4�-�M�ӆ/h�����]��.�4�P?���V���A��(�w�IXۘG�5�AM+ m����&A~J��)���DVI��8��9h������LM"��8�Gxcw�� 1g0*>��]�#z�$2�j��Z���>>��x)�,
J������4�=�x� f�U �K�9���Ӣ��I��e�� �Ȕ �d��'���X?�g�_ ��5�퐕k��6��f�DsE�r��ڱ��c7�U�Q{R���RLCC����
H��l��\> ����b�dj�\u
3�#�o+�R:!��3���S�#��h����HD��b�j��;���I�l5�c��O���TQwjCo����jKUBT���U��8[�d3N ��z�n�����ߏے4��p�Eh� �\��J-��xf)ݴ����u�d��Q��*mW/�!���/}iݍn[[)��GI�j[��$��`%{���� �E��˴*O{����VZW1f6H�q �UI9�l�x:Ԇ�|�[ �5����`���l�j�
���a�5��9�ķ �z:�۲X���R��ಚ�e�1c�KY���ײX��� � ]�G��9���d ����{����巐�9�Վ��b%�I�5����3��{�+X4��d{z���7a�� Z�����*`6��È�� ��,�V���T���88�-is�����:G��/���48v:2c���B�$\؊�1��pPk�2��n�B��YђF���ANRN�3��l]��U��c���f_q��8Y���hF�#�8t����`���E�J)�@6���g�{��^*�� x�\�&����'�����ϗ扜���*`5����ƲX_}��Q�K�Z��u�հn�R�: 4�O�� �%hVe������P����A��I��dH�d�@YH�G�T�%�L|�a>��� Vw�Sgd{W˪� S� �ɇ�jD5��*�Nˏ�Ҿ����@T̈�د���NT��I�OrA�����V4m�[�E �L:w�v�i�~�����1#��@RJi}ltzѼZ8��'�d�L&�ݡ���^}�n;�k��Zǥ��"�q0�*���⛛`R�`Pi"�C3 �F��UC��M̴j%�Kpf_(E�͝�
wYV��5$��B���\�&�Ģ�#����,��$8�n�%N�f�Z�t�Q.A&M�" �L,2 ���') �� �&֪_�_D��nŘ��tN\� U������b���,�}����� �b.��1�oI�Ǫ�._��pi�[nt.~�����Z�ު�� �-�JR\FTC6��L�oV�b9��T�n��h*l'Z�!����Y��d�?s�zIQ� .H�v��q��
;z̐��)���m�<����r���m�Z�FK)�i���f���dsS ��?��O[�"�8SZ�� ��/��>�^تR��Ma�Fڣ*&%�̈��n��| �U�w �+�Ly�^�.B� P�aRD6�F~h#"t��:����i�U
��fvK �^�� |^�h���� Bɿp�M9�����A�Ec.]�-�c��[�@S�/ ���������R H���8�u'���� >w�!H��7%0�dH��`t 8�1��Չ���� �MC�ly�J�� a�,d����%y�$@�
�
�gw�g�ړ�L�; 'ei��c���N��L'*�<?�n:���i�t�2>���j�5x���t�2���n�
V���EH�}a�sNr��
��9y{Li�ҩB�s\��g��ҁ��p��Z�G�u&� �>(�m:IЂu)G�l|�:d���h�� ��c�2��qaMP���F�����>�ӡ�2����\dq��xx�!� �u�3njNХsb����"T6��`R�SV%� Wi~{)R";����W=���oS�EM�7�Vy�5o91،�f�D� ��m��v�,g�_�l6C�%Jm��c�N}˘������;ua2K���Y���o��I��mi�&�����e�}yt9����& �� ��,�dB�J-�F*��J#��2��N�*�4̚��zf�uڥ�ᤥ*���l�v���v�l�.�����x�E�(+���5���3WfEQѹt��U��3ZT�p6
�73�0]�H�b�B�7����o���(�&�p��dqRy��c#g ��.�Z�i���ZP�
��c���r�� >��`��e0��k|i���j�`���|E���DWmp��e|�A�襄�!��L�N��wH�]J�O-H���٪�����$��@*�����HŅ���ZK
�W���Rc�w�|�w���� ?�w9�s� ������,�)_*�N9��
���[h3��YK�hV�1r��,锎ײ0'_�TD.
��}����W� +5�j��G +�P� f��ٱ����zZE'�#�ȺM,������I
{�@��9D�����p��.]�A\�l;��1�NQ{`P�Φ��y�Ĥ��8���:���}l���!&�ʕ�����$)�e!?�v9#�3�ܨ����%�}qf%ڀ � y9+�<�آ�F�}k�1�d&g�v�:
��`7��F �Q��i�}�F�r٥n���m�J�� $�@&%8
�R���5�ܭ��� m�ZQy��rm�p;�dopҙ�dK�������:>z�}~_�Ȱ����rY_}�Y:�-p�I7����]]�j�8�Bnv�㶇[2NB�]=a]�K������%���"�b�����?�_r�g����a�I�%ϫh]�N�X��_g7F�s1�'mL~�s:�j�����є�0�D� ǞTZb��ɮ�
�6b/iz3[UżX�{������;#� ?�<�sCZ���Q���J��Z�������ʻ5��'U |�ņI��šȎ-�t�rKʲ�"��G���%ă,z� T�F� 0��Qw�X�m�{�폾���y��Q;�x*����E�7_��,V�/�x�l ��sFa6�B�#�����ɴ�liE�dW�7��C��CD��p8u<8\�I
��<f�K�#2C������c\�����4g�d�|+ߠ��
��fޥ\�q�S�S�Z�W�w����7V�e���5rrX�_�eW[�kE�W�#��:,�|�b<�;���η�Mb"���O� ��O��}�@�ʤ��Z��H�M��qK���L�3�):���� x�"�}d��dSy- �u[��|}�b ��� ���θn�SL�ė���d�N�V��ݒ��,������Cj]�i���G��Kw�%��E���'����v��$�-j��Q�پ};1�,X Z���Llm&�d>e�@��)�������0/�aF�����"�ܤ� #c�»*�l��[� ��ҵ� jv�C嗸2���#�<��h���T�I��=S'�5��n<ٴ�fU�%rn�p�B��|� Ƕ�k��8�)ww3Yv����Χ�v
�R����r~�V㼶Ѷ���0��k�?b|�w�a �ʾ�X�SR�bv�vzXL���?�cU��^r= ]H��+��r�
��� ���o�8��
*�t��XQq?*?��� ���[S��t
B]�0�KM'���:�H�Ȝ��0%ť�$�m�m���ew�.�h$�Q� |�a^�� ����T��X��z��qt:��y� Tu�e���뎃�1O�Ia��V�h[�eT�|�N�t�NK \�h�,�N��M��t�>.��R< J~��х�Cw6P0m��Aur $�ﹷ��Ļ<~��B�t��(�jF5H�U�X)���hЬ�7Ӭ���s�<�LTiR����x�<H
��J�`��� g�^��c���c��(vg|=��r�@����XRP e�7�Z�?5�>��v�:��Ý$ �䊸�r�jSGA6j{��ژL5�8h���m
��)���=���(�����ӣ��8���}��`;�]���xS��wZ�)-��Z��tA��DW 4�1�'^�,� /��<27�j��t�j|�j'���r��)�|���9@�U�u(?���C*�'��D�&AY�<�w��o����9��7X��x���|'��S=�%H��Ҽd��Nۊ1����P��B_� _K���4'a� u���G����������|�91]u��;"�j˚xg� ���{�м���[1�9.9���\uA�<֬�m<�����9� �{;��د�(j@]x]�,
+��� 5�OAIwi��v��-C<�#e-�UJ�#�b��j������AjpM���cq�lj���mD�p|d&�JREumQ�`5G�eo�$����e�)��:�W�s;c���o)w�8�Wij�ŋœO��ppE�e�I
վ�< �_b�?u������ܡ^Z|�Qe ��`d\6�by �9��y�ߪtLy3ʈr���Ű�ڥ{�/���ި��&�j<Cau&CȒc r�5�����L�R�X����h�s����
� ��Y���NW��I�[�y�֤&�֎��
<��iz0�o� ��KF��Ɯ��j�i�V��N�$�O�
O9�2_���{mgՠ"��f������F���s*0��ׇ��6T������"��f�;K��i��7b�. ����D����8H<P��ųV/jH�_��� ��
����+�d���&;�h&����@ C z��Z(�E�<(�_PK �h\�6v'�
0 UNIVERSAL_INSTALL.md�Y[o�~��p$"��hI�*P���2$m��%E�lQ
w��X���̬H&H�m_ZAc�!ڗ�[��ABϙ�r��m#��;�:߹n
.qǥb1 &J�8fZ� <�E�7767j5�����-��a*��38���p�3��%�BH$�#����$��
�����d���ׁ%�{�>$���A�A���#� 1
o� �9��{�:��jy�����)�����7 ��s!���'�2�V�1d,�e7� h��Cs@
�TKj A� B�ʙ��� Bo�q
� q ��Pp��������o�_`� ��gj� ����Q ^q)�3�������S#<�E����YS����y�c���G"ɧ��A� r���C����p]�lژ^��� ��a,�m��I��A8��2 �`�u�Z��d2iX9�T�4Q�$NY��� ��g�}��S�s:�_\GB�a�Y¥��k�)�_�!���8
�T�H��3 ��19=�� �e�; ����n���;;=;yzx����HQ�eɗ+ �u����Xs��jw vOe���Rt� 2{���dVlCf AJ�I�G&�DZ���c�N��k�d��5 �Z��B�0�Z��D�A�6I�y\]�Q�RdZ5�o� '�GaSo�qC��:�u˽x��*���� T\xZD r��r���_�du��b�ջ�& � ���7��9���,��g�'8�g�[ڞs�Z\@�S�<:
bq��0����="fta�Z5(�js�Ӻ$��%&���%���>�
� 0��c"fLo�M
i�G��Er�oE$�U�){ Y�4��r���*�S�:�� ��y�ѣߢ��߽s/����y��W�!C������ݗ��8��v �
�(�"��_� I�vK�ĝN�6��=�n�F?�������|�`z3W�I�7ՈI�2��� `W&��㞹j��F�q�i��緽H~���u�#Y, �*���p�,_`��Y����X ��#x�f����"A��;,�7+J�?��j8t�q�8�X�Y� ���x��}��*��\�T.�B� ��L(��К����l��8'bm�d(nri�J���'p:��*�-]�����'�؇�|����#��H`pƳB�N�hȃ��O��IF � 2C�D�5�+oU���O�mn|���mym����*�۟on|U0'�ڈ�u�`�̔�}�� a �C�[�T�Pݗ/<��_��r�2��]ti��;�ɟș�9�~�YY��OL�gU�C��(� Q�6Wڗr�z������?��� �&�����"& Ŧ&R7NYEq�
*^y������ژ�|�7�x��]���f���{�q�9굏{gW��GGW����O��UFM�V�f;8����T�Ѿ� Oߜ??9���>qM���KL��� �q=�j��'ϞhI!V�_��}Rm"߬3�>�s��˪9KDK��8�B�����y�C��:ǜ�� b�ᡌW0�vp9/����P���fH���ٯL�~�;>�������������9I�!�oVH�O���.�Nj
��835o����d�������50e�&�Jk���?�o��������i"����W�f�cW��$UZ�Oi��5��W�4�
o-#B̍�pC�Qn�,�Z�:�>��U&j a��Ē��\���4��8n��hs
�[��A���s�l���&�C���1��̄�0���]!��Ϲ� ��1e��T_q5A��E ����G8�iNv��،��l|��S s�yٛ�qn�+�P~�PZ�,g�G
躉��� 2�?n�f�\�m,�N&{Jcۛ
/ފ4�Ou H>)V
V�/� �pfZ�*��#_�(L���`I�b�':wG�d���S ��U��� :�q켤*�$"EQ�<��?�30���L0C�R�seԘ��WX���oe�2!��I� �\:ߓxEW� �FBB�A1ښ�a��Lg�Ͳ��{�'M��}2����@`�%WÃ˱Pf��x"����a��w64�S |<-d��)� ?@�2m��8�vC���r�9F
�G�s�Ŋ��ϰ�-c�
P�i����_b]�����r��v04q鸻���m��e�������/p��b� �����-� s��Xr�c�W%j'ɍDR��9{�$ti�� \(Z��l��rd}��`v�ܹ��۶X�y��]@�RY'�S��&)��<[�J�R�Y=��@�n��z2K�K]@ �� ��9��}���&~s��EP,��{/�D/�y������j��9dZ�ڕ�� %S/��&��v�N;���Ɠ;��۳�$z��;WE8) � 2���BV��Eq�]t8mZ��T ��9,F.�_Ƙ�B3�
j�\�5�kr4�&�*w�����y�wpa�ov���8�,o_t�� ��� X J�A�1/
\��O��D
dȧ��0�M���~�09��ެl��wfϼ4t�
�y�&�[|,�4u`�ι�ʓ���}[I�v�6�X��]3mr-����.4�����CX�#Ĥ��㥼\�|�n��h��G*����Y郙� ek-���bNBU��a����_OR�S����t� ��:��3�}�/V�� ]?8����Ah�̪qPĆ��]>dyl���h\K�ҌK���t �*xX �
��yɯ�����֫�.�<�=U�)m"���+�\2o�ia���}�P���t�>P�W�w� �� PK 4�h\�r
E � diskcleaner/__init__.pymO1n�0 ��
B�m�;:�!CQ�L'D$Ѡ����K�1�դ�#�w�Z�S>�>�K(PC+�s=W��
yt !��1(��DŘ'� G�#�L\�]����P:T��a��}{��S���d7`���9 �)���+x�t�Z����X
m��S��#؇f�l� /Vw.G�E���[��S�8k�� ��R�־�: ő��ӊ��\g�$��n�y�T������L�x���� џP��.�k�7��_[-������Tѻ�PK 4�h\n��� h diskcleaner/config/defaults.py�Xmo�6��_A(���bC7�0,A�i,�!5J<Y�)R#)�Z��� %'��S�۰|Ir��xϑ�EQ4����ʳ��\�k˽4���2!�b�)�l<�ұ҈Z��YJ� r���A_pD�f)0�k��G,mX��n�\*T6����ZL������%h��Q�n�rkJ�J�9�ee�g�2�cv%� �F� ��O6 %��'l�M�x>b�L��߃�}G�� |m����`an���x�x���mM����ص5 2�U��!�.
�:Q���o-����w;���/R �r=$�8�~FcF�斗�u�䣔؋�W�N�^r� �#<8]��%����
Lkg)��TjR� %SR~�8% ]���I�a�q� <�%!�":�O�j DI�Nc���~`M�}N��=�O� :�
3� o�ۋ� ����em���C7�K@��L�9y�6a
j�1*�l����B��;�W� ��p�9$���
��+{u6 ov����cY}WK�ŭ�9��!r�H�|ꦇH��� �g�O$w��3\Ƴ��h�Y�TM��$�] �����
�[<��W���I�B(��Z�C�|��/�C�����l;��8��B�i� Xg���.�aO���S��v/E�\��~R�b�Ԅ����;��[�?z�l�T��x�`X|� x�.o%M���W'[$�ؒ`7��[[�ަ�NɼI*��t{���g��JR���9R�C�^s��U [�� ��g� k�j�r���)��R"J�rא5vI�S�IyV��2��KR�L�}���Z�Ptŀg� �\��h�b^��1%Y0�jA�7Me��$��2�s��s��vݬ,��S+�$�Jg�)�D��J���ڙ�0���g�K"uf! %\ѯ��zBڐ����#Ԕ*����_�
fjB���L^�{6r��Y%�)qrj��K���_��FC�Y��}�j�d����u����QN\��e�r�8�� ,���txF� �� i��A�����< �d3�}Hj]1�?���W��l�O�-~�G*�+H cIm�yE��i4��e�9��4Qac{���a<��!:��8��UR����E��ub��@�vgH�1bjE�ǿN��ɱ`�?� �٧nTW��P��Y�B����P�
�8 �L��(l)a�O�~k��*Q7ɇa��y;��� fr�����=Y��6 �Ի���z
Xp�w���
rħ>?�=��� ]`g$�v��ʮ j��
��v� H�m�b���>}���/��_PK 4�h\p���J
�) diskcleaner/config/loader.py�Zmo���_A( *�r{-��h�f���r��%W���"�6/���t�����;���(YI��mI��Ùg�C�A,��b�v�:�,H^&�� {r8悝���椪YY3�~����bq���N�m] T�*����:�\i3w�.����sVP�Ի���p�v{��r�uDn���
���ʺ!a�1�t��4)h 5�!_.~��8@V@H�� G�B=�¿��{�M `+��/�� l����D�s�H�GJn�V�MŊ�y~U4+�bEn��O� ɵDa�j��;*b�,V"��"�Ήr�zA�Bh���
��f�
[��A\)�K��Rk���a�/��ep�_����?��#��,��/��ž�|_�Y�&���Vt�D��A�8fq r�oW�ZZt�E�B?,;��
x}��,�ٿ�K@=T�� �څ�{p͘A趺��]!�(n�e܄����:P�/�vX� Ӝw�BK�[�� @�Dz�+����%�Z�m�$�ߐ@�(��
��: �
�Ӳ�@� �{҄j&2��\>�mY�a|z��>�-�e�G*�u�ãNX�ER�T� �f}b�LsF�Dq(�eNb��0XC ޙ�3 J�O�]Rj��E��G1�%����a�RPj�B<T�+[� �}<l�<��X��p��Bl���4dW��������%�5��[xT ��y`A�%ٰU���x&X� y�1,ݸ�N�*�D:1�E'Þ39GAx�Cq��h����"�džj ����`�/�vAW�O,l��v vc��g�,y�t�j��u�==)��x�rZ*g��O\}����u�r��q�0N�SȭΧU��9��[� n�@��z�e4�C2nP��!��[�Pofd���D�
�
1˗G0k)|Yk���v6��˻v�a��u����75c1�Y�J諢EF��Q>I� du��$���S
#�^6C�Ѻ.k?����F9�C�St�Y��V�RfP�\G�=�c�� �Cρ#�B@�mTS��p� * ���du�#�e��Ȅ%� �kv�g�$�%��TM�yd5.1�FR�5w�K��3�����%B��c9���J����_�l+���1��G�6���R�t3�jؖ�+#Y�B�DŽ��1��'��V�a�9�tG�¬�,����is���G��Vs��G�3 Q�6 �[oq�g�c5�J����2� ��,�V�Sq��::@�����
H��[���ӧ5�aL�b��<t*�u��߯ ��h k�K�U� Y/K7��#>a�s 2���thc+.��T[ԑE+UX�RJF�>tS�Nǭ(`1�A j}�� ��@�Xq��оN���'��AK˻��� r ��(hG�F:�W�/G.� ����d�� �Wj<><�K�h�����3�R\;���y�)�B�<�x|��=�, �<|a$�=�>�V�zɟO!��'9n�`��R���qNC���K�;ɶ�������Ò��|=첵t=����մ�p����C��''?��� 1C�!Rh�"���*�0����6 �����(�߭�@L�����J��wL �J��1�6�V�@�^>�/�'X��,�M�ò�b|X�Q�O3�.�l�x(4�z�� |�F '%��� ����7��Ȧ��0A�9�;�9�
@D��[����b,}�� �E����P��F2f��� �J�$�6�QL����ސy �� Q i��mwq_� ��l��&`�z��r�Q\ �<����,�t����zd<c;��#mu����7�8+�Rn�ªd���5��ǐH5SX$ U�� �di;�[N:s"IQ{�1d���dw� '�~ ��gXŰl�fv
����/���7e��*M�� |���ա���jP�3�m%/OU�?�ޡ�)�=�K 5J˪�'�e�,�`�0�
��8ŀ��+gn��C�T�~%���KȎ�;_9�#�p�H��RtK��Tfu؝�����D�?�:g��o�E#)���羒��w�uH��<�����/& �
�"N _�ܓ�2Y �:�������*��[�+�7��}"$ lH� �VƆ��X��fP�A
�]��,>AxH�
k"SE��"�Lݓ�3�%wQ�� ^�'��+Ǭt��&�c��rX�cc�(��� [� �j��' � ��]@d��é5��d$��?|���=lU%Lŋ��=AŔ���5�b~�T ٜ�k֪<mmXOG��pr�� �����` ?�E+~����:=�1(}T��d
Y�@����}O��w�TtbPۭ���M-�]�eH7?����4�J�� � ~�������<� � ��m�9�kn�:��Ƙa���יK�����i9 L94���\�Az W��� ��1��M�13����-�$ߤ}1�m�H�VdO(^ J�q����%��Bó��K��k<
�'[*����4�tO�'yf�e�da|,�܁w���Y� �Av���8�E� �w q%>
� �mbxx`�g�q���R���-`����{�4fEZS� �<�iR�l�!ئ�7��D��OM��tv耖VJ1�x��4�V;�f��� dB� 2f�F���
&�,iN�I T�?,�IN�1�Һ'� ��I �迒��Г�Y��PK 4�h\r��,r � diskcleaner/config/__init__.pyu�=
�0 �w�Bh�A� �!b٘�vq�����T���{?D�VcNGϭb�*I�VboC�_��T�����A� �;��n�1����i��&A��� �bƌ7| �� h���'| PK 4�h\5DxA� diskcleaner/core/cache.py�X�o�6�_�s *-������0ࢇ�Z�]�[4۾ �����D$��-ڿ�3C��d�ɶ�˃#Q����'�\.�� �r�oD+�c�6L���o�-�RR��������U��7�NV²�gVw�tR+�Hw`N3��bݞ���3�����N�#�S+ ��㌫�U� `�� W7��%h���^�v��yݿ�d�lŢ6�eȬl���]��m%K�>�@�h*�a� r퉿�W�� ��JX� �H ������b�ed��_�Xu����[/�� ��5��[0 ���F
27�Fk��Л�?�58��[���Y�h���,�*]��a�j%<�J���-B�Y��9{�Y� �ku'H͐y���.�}ˬ0|�3�/�i���0���/ �n����U)�=�&eH�e
�r���(b��Q�9M�q��r� �[ ��v@ p x�o��yn� (�@��t1.�s+F���H> ��<���KH�ӑ�d�40�(<�Y�X�X�x�O��ή)��Rs1h(+2��w��֜Dl �=C
5av�E��Rw i\�?��/q�"�5 2� Q�i����+ 6�U
F��D�a* �%ĕ ��tXH�� ��ԟI����%]y�' D<� ����ی�����>�����Շ|*6���_��Y~,�c� .�����J]�-5Mտ[JH���f�&�� �i���Ri�۫����e���yE�|����xQ����o�XD��� �ȼ���8<�|��]v{l������ ::��&Α3��5� yA���;� �U�������頎�(H[}K�i��m�V ˀ'���u���G�k�s)�ɋ���;��sq�$���������c��LJU��{J� ��h�N��G������gԆ�K�8n����p�o��� �#a�*�� �ɢ�� UB���؉�JBd��K�2L\����_"�_ В@G����=��H}�B�n+~�} �'9,7i9�0�B@�Hq�֏�����fOzm�0��oq��!���Xݷ�A�]�`�����u��o�k��)ǧ&2�s���4$�~ ^�h�c�턹�����ޡh�xMӄ��H�|'�۩�� ֕v ��d�؎"� :� ��j�2��^B
Z��T(4H����*n�bE�Ue�E�'����;��� gg�E��/� �V}��34\����I7SPI�N5R�&�s�o4���}�E6�3��2��T��y+�4и(}��l���_~�̱"����GG�
�
+�s��A��h?d���{�2b��ۅ��oc4d��!<�țί�Sp�(
mo�� \,>�߉�������X*?�i��\�Q��%��J�QoH��p �is�}t�?7��?"�(���g���4
���
����q �� ���|�\bss
��l0���OM#����C��F�THx
c�-x�#�b?u��<l��}���-���[?0�}E��p���e=:O�Ѯ�R�]k��X,��O$X/�,�F(����S�� ����?xn�#��j��:�<ݽp$Cu�ʮ�W��Ov��?��< ���`��O�����[A�l��MP�^g��u܅Z�Z�t�d�.�������0�B~�� )�U���� �����6Yj���+
�>��9b3��RtV��Hn� � f���
ji��D�<GV�.�oj�R,�_LZAҗ� f� Χ2���.�4�*� c�� ?��N ���4�}��x�h"[�Oj�n��
���^�4�:[���3U��� �2;�蹢抗�O��p3@"K�T��.��A
�a��'~�`�� l����.��"^ve'��1p� �ڬN�R_�� �DH~�c���Ă�5��k�G/���% �2�;Ue�v�X��3|� ���y�^/�PK 4�h\�� fP �% diskcleaner/core/classifier.py�ۊ ��}�������2/ـ�]�"��ކ��驙)o�讑4+��[b$)!&!��(�� �e�?��r�"�TuWwuW���
��L�K�{�sZ�� ����(˒�-��$YƜ�LYBӒei�(�t��$��� ��$%���LV��rꑂ��$��i�0��pN�,+K9�c6�) D1
�eN
e �2lK��H��Y��,MB -�"K`P�
X���;�1%"M�I�t���<䋘Mj� �) 3K���q��d%�{;�B�A% �%Ħ� e�)�k� ��~�)��q��7�Y6 ����Dc�(�po@�V8RV�CВ
� +!�ݫ��>q�pF ����[�o �2�uxxpx�0!l�)3M%֝����ݓy�qq��R���ÅJ���<86S�Oug��پ�N��gS@㋂R=�*Α�y�>���,�r�� ��y��y��?Y�B��lF �S �CA���l���h%������$�,�0h]�N��# ��pZ$ ��
Ky`Jg$X�x�%�g��=@# c���,����&��
`���ӱ�~���O}�d�,��H6���g�|u��W��%9�qN�as�O�Mx��쐖"��C.=W��z����'l �#�,��b�V�E�S9Z� ��XB|w�' ��t��)w p<2k�<�3�R�M����h�<��휾�������壳�ߞ~����<s��HC��|��gPDd� �J ��N�)
�l*���|�i�+?Y�+;�0�l���?��_�}���ɧ�/������E{��g��c�v!��!��dR�Ӊ���np�� �A���@�W�e���f M��xiv���P�6t��� ^5aM�0���4�
FP b�T�%����?���b�:I��Y�����g��B��̀Y Z���|nP $O-�9�Y<���^L?���o_o�|ja?�,���06� XH�[�l�%�%��>�ݳ�z�0[� �#N�� ��.AK��MSP]�+W+�
���D�9��Ӑ��L����^뛎< �;��A[�sՒ��,Z��l��֪���-S�� Q���\g��cT��h!��N�GT�!~Է�d�6��G�U�
�0�B��c�Ӏ�G"��~p �O0/�e��k菍>(h 3T�
o��9�-dO 5%������x����7��$� �� l��+;�mx�����g����^9����' � ���W��Ľ���?����75���������˯O_�ք�����QK��Ј��;f91� \����f��ge ({=٠{�,]�A��J�*�5p�W\�}hP'��1O vE� ӌ�R2ZG*:�}){(#�7���"~��0�Wb�Q �B�r��9� ���I6 5Ld�o/�U�/
�� ��3 )6!
QZ+���;\��H��j��K���⪨m�հ6]�Zc �k�|
v^��X��Ģ�Z.�s ��@��ZM����z���rC:O,�hY��^�lh� �uF�( r���ӗO��E������;��a(DUk^^3{w�E��hW� A��������Mg�l��ol���j=���(�4{�➢1 﨧N]�}�<`�{@��M�#�9��k��L9'J�5�ԥ�e�5����J� �n}ʸY`̨]���Eeg�� ��5%t�Ğ�Չ�)f�S�����]|@1��,�̂��UŔeZ�T�� /{�qU.�o���,���ȵ�_�u�f[�MZ�nI�Z߂O�E��_i�pFq�{o�� 0���ȸ%�:� �����I#'ZU?�XI��\3��5�k [�����B��==Z���,N����@�� ����� q���OS�[;�3ӫ(�Ho�q�f��pݼ:�Dvv��%� ����Q>�t�����V-|Q�_�&�L?�!÷���N�b�v1b��y��N�U��r�Y1�Kc�˻��im � �x�F�ϒ�I��]+ں��)�T��ð�7�2��]�ku�ko�m%ɝ��CʉC��)�Pr�<`�4
�i�op��Sv��pcG^,iO|%�I���B
<C+8�R*���[P4Q��Ь��)�� <]$��uU71�����X�q��6^����-h{��c}�m� "��eZ��hӽ^+�>�v)�P�]� g��&�ӫ��CH�&�`�wL e��os��Rn[m��r��;�Z��c�]b
�e BN����V�&�L�D�2� ~w����<2 �A�N��z����� �6�����~�Y������H��O uvbJ%O~��;@�}kd R���6�M5�@�q�ㆆe�f�r��3 �= �g%܋z!� �bs���� ����o a��Y���o0�F��������a֜�Faf%���PK 4�h\͙�hK B# $ diskcleaner/core/duplicate_finder.py�Y_o�6�� ���WGH���j�E�����-6A�!Z�c^dI�d��~��J)Q�s��Ėf���73�t:�\�e&���L�Th��b�RoOy��`JW@�&� �P,���� �~.Zb)�rr�.��Kv#��;��r'XY�`ҢB�
����� ��x�$5
��w?��m�ڲ�ؕ���ȉS�x���㝂]�+�JO&דMU�X�5O2���ܷ� �ޗ�Ss�B&z�~�
�~O9��,�F�T�I&x.�()*����p ���7�d2��;��2��VE].' >��9{�߬��} �aHF?���]{�=�Q��%���_h}�ij���A|�ي�V��H����RTzO�R�'�)�m���gg�kT��ޭ��
[�J��Y&r��|�H_�厯3��'b������k�fk�2��� ���u`F���t"}�U�o�(G�v
��s)�TT6@���u�L����X� R�O��� �[s�`��|R��� K�x���S�BrxF*�a��̅��{7(���f�P��S?��/G�v �m�,5� �H����������?>ķW�>�\}�������tb�!�e.u Sl����i���m���; "�>֭K��
H�;�~�a�e��~
�H�� �T�x71#����S�Y� b�lgǭ~� v�
�ބ�x�IzA�Ij�0`��v�f ����̓��MG�
��\�MQ�ou��}3+.�` �|����m��9��L |i�~��;��kO_Yz�`�z���� F*��SM�ё��.��{ N ��A���`�=�5��b�8j T���b� `�V$���OO=9� _�V T�x�Fci��`���m���S���v�,�y�7��]�c�D�ncR��x�9>�*��Y�b�~�rX~�N�?oe��� �[+a)�{�f9f#&_ �Tgi�ޛa��
��#ܜP�ڮ_�� KY��Lj��Y�Md�p!�J�]i���¹Z��-u���n�r��F�V� �O�Rbu[��9� ���C���7��G� U�(�p�� �<�&���ޫ�� ��7&c�T� �ap23�����e�͕���Z�_�'��^�̩�#;�,}��!��{�:籟��&��+��
�ەdd�qby���J��}W jY�w�P�
�Oe�3�Dp[��6�m� Τ#f�L�B���.-�c�Z���F�� 7�/_;��1�uo��WUW{����=ϒ:������$J�oI���$� �\o �i?r�i� ��C�w�M�� Їi#^����~�t'>'��l�����H_�!G�<�6f�W�c
��iR�Z�p1�=Pjw�5�6m��A�ɻ����k/���n�\8}�wn$�ةY�(���L���,d�9��3`A%�
x˟�����3`��g�)vwz ���D�/(RS����^ៅ�U�u~`� 7��̊ஆ�.x�����Y�@���̓FƬ���W{fv�.s�E�ߐS�����ܢ�
�s�o�����)� r�j��DyJ�* |�;?-R�j���1D&���=�I��U�����rl������� ���F�j'�n�� >���4�֘P�V_�r�������Ҳ��� ����n�.��q��Y�cݫ)YZ��(�Y'�¤�}Ag6�x�4��!�cޡH�Xu �/�'�d;�RJ7&�� <�*�;��'�f��кN 쨳�%������8��%��&�h�����H����n�<���I[O��T�Rܹ"F&�q��������6?jtn�l����#$#�+V��`8ѳZ� ��*��� Mk��B_ڰ|�_��e������`+�O�L����ɼ����9E��2�5��J;���/� Ȃ�F5��<��i8o<����: ��1�I����=�_ ���_��� ?c�{��6��� :�$MeAl��:O7��5ڱ�T���o 4��h�;�9(854t��^:O�0� 6�:���/Ș����i� �������l�I��O����_|Bdx\"W�O�Ǚ fF����Z�:/^����������| Ֆ� m7�>#su�8�F��lG�c���z:g �`�;��5�@�Ķ<Oᚙ��H���Wd�V�W�Y�@v;�Gu��A� �K��S� �nMļy��'X��n����5 �B:�,^]�x�$������^���J}}^�^�T_�F���� ?%�1O�K���6�ݐ�{����n�n��!�QX&* ���m�^��30��� ��` �7cͻɶW v��_B�B��=
��A��@߮w��y��m'Ū
������y%�v��B+e�~ ,�_Ӿ�{ Ʈ�0���` ȼ@�я ����� ���PK 4�h\���K �` diskcleaner/core/interactive.py�\�s�F�����O)
�f,���v�0UG ��eoS�\Ֆ�5%���*4Ҝ��|�"{̷uR|qȑd��kn1�m�L���噱ʿp�u����Ҍ
&�[���#�~�������-i���PϬ� J:>����f���둺MM��&n��u|cǎw=��ՠ>iQ�3����!#�a-OX���L�i������eC��匍 ����-�0X-J�V����7��6�ۚ
o� ?��`��|��w,?(�_�Q
�.��~ �m�b��Y��3�G
�n:�3x�;�4�<���P)��[��{A�H#� v�-��Q�M�'����G�;|P��< C�6y��Aǣ>g4B� j ���&:��pF�i:ڠ� m�D�_Z�ӫ�Xu��A�ms����6 �3�i�5�I�PNS�D[��A�se/�b��V=.��A��V� +��t�l� e:�*�X�C���uf�i[�Jc#��D(?��M�qk��w\��t��Pv�R�5l�7��i�Ƭ��V8��$��4�K�Ѕ�k ��Ε��RMW�� ����Tk䐘i @ �,C�,T��wt[!���=
��� `��ɢ�e2����m:k�m��OΠI �:4ɴ�����o ��I�q���쫔T$�'g� }�;�������7.l�:�q�MI]�i� ����Z�~~�sR����6������ ��?�[D��Q�� o,UD���g/uo]�];���XM�S��?��_�����~�h_ȯ�������ǟ���@MZ~ϯt���:KܬϸV ��r� �Z�5(�w�>�+#�JU�� �Z����E�mljVђ� ������q[0v�1�L��������O�k�V�e���4K �� zW�ؾv�y���ë���h�����ށN��k���s�s;mp��9L�f�v����ލ��I�8��b)��
��P
C�:$�i׳`xp �
]!�!j@�h�z���9N��m�5�0�l��������&�����d��G!��t N|G2З���]��،K��Vc�Lt���2��B{ � �c��ɘ���Kx6���O��]c�W�w�le���q�~,Ք�o��॰��!ׇ�ӈ6
Y0�|���*����s!����E<X����-3`#�c% ����|r� ���_�D���Cjz#�]���퍪�4Y��r�����kݥ�E�Z�o���?���4H��=&�� �ə��x(�#��������!B��Q� ~�D�A� 2�m>CLy�<�����h���*@37цk�Ђ )H��(i�j���c�����"�
\�MP��:�Qfg��,��'_*'#=�r��%|����ĵ����%�v�;w�w�Қ�2��٘�ҘH,�J.p�;'Ѷ�K�XE�"�߰�-HA,}���h�����'�:�qEL҆aH,���B�"I�#d,C����"�|XL�Cؾ&�H'�rN� ���,pSR�Y�+�m�>� &���(�y� �M\UJs�,�qx
��!>��<
@Yc�h/ u�7��ow� ���� �A������1
R����:��a��:M�k� J����7N�¢se}��J�4S%�r�`m�
��U2u��מ�;?�@�BY&_2P�א/ ��mNQ[
%���A�L ��� ��F1�{
e�H0����Ȯ�����*�����I�P��n�` m$�j�V `�;�� ٙ��W�b ?bD��8jlX�kZ@:TI�lPc�P������e�x��E�H�5����q�yb���
�Z7�z��jb��Y�_%����
`��q��?w?;��櫍�N� \�U��$s���3 �q}��|��T?��#,�D�k��
��=�0� �n��
�"q@P�<���X[���伖h�����+ɋ���a+v�y
Ŷ��3�e$�1�qɞ����{�X��i������i�+e��� lq�xH��
��TQC�+sQj�Ӡ�%�|����3 �K�%[�3q� �l1� lջ�ew���� ���x�5$�����-a6��ɚQz��ݕIۢjx��`�vWr#̙���KQ�F��D�-�\�b U �b�w�!cYcy�G��bf� �{���yt� B2�]yL
�y�n�V˜k��f=� U�bWe�� ��-��3]"`R�"�;�@�� ���,F���L��˂v����uR�:L�\{�Y���1���o��W<�Xm�� �iS��f5��TxQ/3�Lu ��PzX�B�f}�K�� :�4w&ƪ��P0YF�"ԖaA��Q�B �(58�K� � �)��r6�*"W��C�͖��� U�5 ��P�F=� �'��A��Q �*��I���9�Ĥѧ8I\ 1��(�L��b�}�� �C�ms�r� gIжk�d"6�0��mv��iw��R612�l@�FX��� B�p����� t��X�ԥZc�Jx!��8 '�o��G��$�W�x u�Z�����q�����K�ic~�&%2:_y�踩�S�<��D���d>!��d P�$�ٸ��9�@
�����&���iT21� �Q�7��Q&I]�D@�h�M0.U�:�W fwu�.p�Uݿo������\�S�+�[w���vU��Ɵk�WzW���`���h�� �N}�x�53����r�Q�u ���I��{A����e-\�gj�, M�[�dI
<x������[m���o�������������������_i�^�pu3ގ٢�=�I��M,;Xs���4&��<��y�ЅɁ˃��s�rF�K�z�E�)�Ď���ړS�ry4m�9_L�g{�{�Re�� @����� �YD�$�@��C E䔐`"�C��2NJ<�*ϥ;i+:9@k��� ��-�rd�S�L cS ��ٞ�P�* ZD&�q?��a�� s��mQ��?�:\}���� P�Oe֜C�ح�[�Ed�[���XKz�垠E�5���f�� e��⸌�aaޯVgODZEA���dY������k���G� �#E 2J���`*2"�� ��n$CF_�l��A0 ��Y0H�$ SݿW 0��_d첐������NJ�d~mR4��H9ܦ�=:����.��Al�<5��P��q��T1�p���1QD���6|D�D$KT�d V%�J/(ԁk��W*¥;ˆ��ZL*�����l��Ҩ��6֒;q"��:������ � ��D�c��j����P��^^�>��=��*o�̘�L�U1&�c�&�_(�����"q6��e�H ��6Z.[����^$hp�� ��FJ�[� ��*� ���!E�c �%�7���eK��{��n�%�Ȋ�ո~Z 5lU��O� ���� g��K>���յo��d�=!�����yS�'�?x�|�S�g�*��8`${���ʘ��"z6�ā�a�y� �ɒ�3۔�o�k`H�їS�N�mRJ��I� �v�I�����ͪ��Ը���!�b#W�%M��>�R�v ��ЇȢH��"��'���2��l�3�}�(@�1����|���x�Mn�s�Y��.7
�z��|�v� 1�o�|�7�$V�x&Q5�b�X�V�J� VtҪ ~J���hq���H=��F ���2�\RļG�Տ����p���$$.���`��
�u�ȡ8�)N|���}����3�B�/�b?�9D�ݩv? �� �]:� ������%��Y��c�4�4��sYSo�V���Z���N�tF<j6��6�W��ZC�v +�ALh��d߿b߿`��j)����2��d��{���� �U���*��\���,/�yl��]�+��Mu I��q!g�x��=(�
*|
Pk���T����v_ \X��4�8�i�\��8U2�6�b� Sf�8zD�&�u�Z�M �� <�ezs j{�_:� BqL; ��j�`�pŷ���5�k$�Fc<��C �c� KN'g�NO� �A��h�H6�����a��>��m�o�R�#��9i�x" �6��mWYx ߯e�y���c����x���!�j��[2)��8[ �[���Iڄ�Ր��� T�y�0�H�ΨUX��"`��
|<'�B��V�� ���(D����v@~}��繞Z�������R79S˞E�4�ε'��>��e,V�������!�9�qF:�ͩj�J��-Kz-� �8{�^n ����z��yz��b���I L�֞}�]�|��n�E;��;�w蝻�~�"���Sջ�h��Gp���]��y��=22Ҍ�4������GC�T �|T�?����Oi���/t^!�9|��W��W ��j&�� d6h��EVr�V�C�Ļ<6�&���t����_(�,\��z��~����� �0o%셇���������e»��\�-~����7�"[� @���؆��%IJ��#!����{W������U�A�2���2&� &
qY q����� kO t�>�#�W��?|8p
��O)wͮ6�<7��� �x!���"9&�|��{,)��������N:�����dI�)y�33 =!��s
�"S���cѳѪ�I!O�[���e;� �J����������'/���r-['J��m6M ��H�� ·_Q�E\b�zY �����,%��|{�Ò� �a:������ �Üe�շ���f�6A`��*��m��hOa�ovl{N
s^>l6i0�u�(��� � �^,'���u0���I_ѣ�R ��� �&ǯĢ9,.+ �(�T��Z�SbN~�&�N*�7Q�"l���䟿@��#8�E�V��nՀ1�d�T���
��� Qa4 Ƕ��?���iX^!��(��&� �R � wZ8��}r�lw����BrMA`�؝�
5\�ȏB��Y�J s�= �;vg��K������;ݏχ��K
��8Og�[Z��v��dʄ�ѡ I�&�c�*�,�S��x(�"2"BF+x���LVH� ��l�|d�B�6�W� ���8Ap��*���F��x�6z�<��L`.և�`c̸-p2J4ꈈ�^R?��h Gh�x@��o�%,o����C��Fl ��_!��4i�*,�f������O�k� P�8�͢� ��ȡ�� >v��%��f��tfN@u�P�2 ���]|*`\�͑�i%t���ٌ�� )�+�� ţУ�s��EhW@O ��PK 4�h\��� H2 # diskcleaner/core/process_manager.py�]o����~ņBໆb$��� ��vj$�
�N
���I��H�K꣮�E� mP�C��(R�i^��C��E��e%O� ���%���t�G��#��3;���8N�z�\6�c�gl�dl�Q�( �|�&aą�Cؽp� �D��4�s ��T��y�� ��g�0��=�S;��<䢷 �,����=�
������s`^�p�&Y���49�.�mE�7ɒ�� D�0AR~��a�\���C���Z��#��,҈��PL���1ϼ ɸ'?�q�r�e�ȕx��z� UD�?S�� ���K6���"g���G�"\��P ��3��D��[0��z��гņ�$��2�c:A���< x�P�(��܌ϒ�p4��"�1�����F}��ɀ-���L+�o��b����x�q�IĹ�
' �x�Ӳ�`$vQ����څ�-�s<�sM�� 0`/� +�G���(dr��6��wX����k�����0p<��=Jەa���$�0�E8 ݪ)�Ui��N����f ~��0;.$�ev�,X�C�18�i�P �C4w >�K�a��
����@I� $�$��n)����0 '��#��� �m����a����xW�#����)���Iik�
K'�C��YP���H�cTrC�]�(��]2Y�t/��/تM�|~��/�"C>���2^��'�jŰ�8�u1�_��,O
o������d��t[,�~� ��6cm��Ԇ�Q �٬��GV�����~�Ae9<j�
c��N8.s.� w�NM���;E���6� ���ȓP���I `>���e���d������6ETpނ�E徘F�Ծ`P�m?�>3*U�;,E�m���!��L� �!JqX�(��#^-b� 6�P��2c�"�׀�m:�X�-�
:���ȇ7����r~���8� �[��
z��%�}q�`^R�Aa�A�IF=���' �}�g�3�/,h�@c��k�فݕ�{Q�ϳ�@����(9�K9�u b ����bt�r����� k� vA�%��Qn�z��� (��� �� +���r�MW�a`T��C�0d�h�Rs�a��<�eg��q� W�:� %�J%��-���ݾ$��x�(� ���Rn ���W�q��<�OS ����"�!�6���
��9{ӏ
~)˒l�<!���W*���qY�H��I� �k��Mi7��0��.��ʳ��R ����2�|7��X��>�U�d6C��+��~�B[ �l�N� W��w
� ��� ������!�=uwx!l
O��t~��ۣ�l�I�
���t���As�4g��b�֜+�1_Ɂ/+Y�LI��k��U����c�v���LV~��
�# ��:sL�l2�9�TyI�/o6� �\LaaG�2�ng!������^K���2p�ʃ����X�>ŚBs Y��Ą��ܧ���"�Q8��5m�Zyi$ T���7 'uDFс/����q��ԑD��+́��b�rQ�@U� +k��2!��M���
�5���\��-�jY�v��[0�Y2uY�.� !����a�\j�4�Nυ�_��v)-V�ic]�S��{��թ<���K?�+��Rᫍ cnvM�} #�9!eZ����:�Q���0�;��5�Y�x���������B�?�K��`k���AX�:�@�?��+[�{�� �!�����$ID_������^ko�,Y�nk�ʒ:r��K�wƆ�RN�P�� 8��i���N� �|����zg F���Yu�ou�G�D P��Q�(�=�r
�a5� �{�_���. H��i�fB��L�c�rBTS�<��l[7�
T�!��7�a�v�?�YC�*����K��e�3P���S�`^MB�R�ݫ[�*�I謤<�M 15��س�ؓ��Ɖ �3&�]9�5h�>�1�"c�Ђ�[b766X���^{��к�a���WZ���l�]�v���q^�҅b�(*t/�Օ�罕��lbks����@�]��Q�:� �Ū�~
�o@k�P?XpT�54�ۀ%����<��28t����k�� �|[3E�j�E! �eu���v�D��Wu�V ��E٨���W�x=�1*���cq�v �1������7����-��o�ZVv��$l��0Ǜ�Q$s9�)��Uj<Ƭ���.� ���cT�� �}��8Ϛ�� >�|*+BЖqܮ��<J� �PI)����l��Z�(��H���snw<��ηA���@\]��S����n�:#ڬ!t�� �~���|���?���_}v|���|��ݯ w�q�Cy����������7+4�*p�R���T�|i�}z[� �������Íb���z ����?������bGm�$�d`e#�<R��o�5our��6�
��`�,H�������XS���E�D90"m �ҏA{�Y��v�4�2���G� �d�t}k#)y��z�::=Ji�H�m�*��I� >-ӥ�b �_����"�v�]��^n�"^��ѩ���r����`�������m�#P���}�#f��Th�"��zxkgNw��$qW?��^�t�G��-���D�h7���%������:�wa��c|�b�ǩH&y��3n�q�����8"���] �G#�R�w*����h�u ������j�]� V��[Ǫ�u"�|��=u�T� ���٭Yb�Jq��V��,g�0E�A Por{M��`I�����{_ }����d��Ͽ~�� ����� ~�gCL� �㽌=�R4a! ���4��'u�r�ze [Pdx� j~�K��פĞ�q�0j@N�$�%�^bo�3Yy�C��I|&g�~L�2MGc̦��?77��,�w�巟�{��'�w�?�����w��+������qZ��OX��~���_j�F�l\��E���
9���*��S�Q�<(��}
���<�����`�$e�%B�Q�m�����ܸ�I됨�atX�,� �#6�� = }V��
�T}��d��DI;��9`J���3�ţ`�A�f�e�',�wDE=V����j9A������"�4)�p��!>a�"܃,�>A��_��/�_]��������ŷn� ��D�����xI�3�:�ƞR����ڏ��Bɬ�:V��~v�\�a)�9��*L�)��+�ZX�'��vB��,7]�\�o���!hY�_�E�t�3��5
V��6�U}�"6�P��j�V��/PK 4�h\���d�
�( diskcleaner/core/progress.py�ZK����W=0"�3=� �@� ���Y ��Y��A��M��i�6{4�Y� �` @� ���� �ƿ$U|t���eg����-�,V� �J
�`�[*(O)O6d%�KA���bA�r��%�2�,��`p�`Y�i�Q\y�RZ��j�!�n�f�\��W$�h̩ ��
�q��X��t:8"_�8;�lIkz�[e\ KP�K
���=!I�%e������0M��KK�OJ ��"����o��L� OY(�s� %[2��%�9��s��yƒ+*�n �΅$Ŧ�oQ��\�K"7+$4�Y�pq6 �,��6'�<��n��'{)L���.@ � _�������p2 � �����Ms�#�
�P5"�IF��a���"'�\\�f,�\�����̃9�ht˶���
v��$� : �#}a,
�,cY�2��w�C���� ��Qx�N�?xx|���_����1S2�N ��c�\ ��a�_VvPoR:'Q�8�Q4��(h6?w�q6UI��))� ��!8i*j ��)G��V^p>���&_圪� E[G�� ���}G����E\5-��lg� �\�0��*
�c�(�}<{�3z#q�
�3P">�֜�->�Qs1:T��E�H*|�V/�sh��h��:�U�RII ^;��V ���@=���@� ���0�����d0���T!c!#�Q'*�C�o8�WA��HG�];�Xa� e�_*��E*>R g�m`0��
as�5 �MѴZ
Z�����b� 48a��2cH�qFA�����+�K�e�$�@+�`�aA���Ũ����K�#C UĠ�p�/"%����k C�Q9�ͭW�\�蕏a��SY��:���Fs�̛�Ԁb�Q��H��YcH |��k�����F��� �!����D ��ŻFg���`�(u
����Mav'I^�� �)G�� O��,6��~��d�<��+�F����tͮ�ĵ#�� 6_��Bn�]_����$��ƞU�Z^^.o��A�1*�!NjvN�� �p�i�T�H)E~�Q�� u#L}�"Jr�#����G��RzX?��1O�. ~����%���� � V�v<ұ�8G:���}r���RJ� ~�� ���1�tQ���X���Q{��� ��
#M���w��{j�5��LtX�� �-�Nו�;́ɭ����_9��YY,� �#p�9��wc�n���o��X �Wt�l�^ X�q���G���r��=������L��I�� ������?x��\�Y�M��k�.2Z�37K�����l���
�m�/L5D�B�N��&& ���Xk| D��w���d���l7S� [ߖ� C'��k�Զ�
=F�!��?��K}d�G��L��[╶�s%X�ӹ��*�$cvV��$�#v�r(#E@�<��tC���ḛ҉��]��� �dZƆ�4w9nK���1<%fx��G���c�D��,��"O�����������,x��v ��8�&���-x��"h��:��m���:��5� �V���֜����K���B�N�@ݦc��
b<�M<QF�-������2�Q�����o4� �Xݕ`��z��Z�|�<P��%� Ϗ�M6G���L/����+lU���=�E
���e��� �Cr�HFm V.���8�j�<�;�o*(3_���y��_N�{�k�u�<&��¯�)���"p<����g���&��e����y%�UwZ�jip��������6�i�� ���>I !Ժ�@d%Ȍ\�̞���u�-�=ϡfS��f?��:�/kƋ2�5�>�|���M���nGeX�*=��[\��{e���M_�O6��Vh�B��>�:��4�� X�!�P�H�� b쏤ޖ7�����$�ܬ�~U�������>�y���JL�����mQ�����UP5��^��A{��)�߀S�n���V%�) �j���)��uR�W�S�a�Z�~�&�z�2�L�Q�[ɒ+G�v Kv�kd'�54��߳N�Y= oPC`ҹ�����c� �K?x�� �CH�~��~�[?�� �я����� ��{��Sp����^����lӾ�C��l�٤٣�j���R?i�tg����;�X�+v*g��6�jdzs�����U �j"����Vl���;K���8�>;���5�T��4��֚��{'dRM��.���6�2i� �[�HUK�,vYv��G&#�$0W�w��?_���w����p�>���J�� �X�����)ϛj��.im��ժ Zۚ��%�� �k4�u� �
4�&��O������=д/Fj����j\xVoI�_Տm�X�*���M�5�ܝ�9����۫���(�T�}HQf�� ���҇b�C������ۮ4\�p�p��J��Pl!��M�{K������j�U߃�, ����v�T��V���B�(��R�_|l�oEx+� FN쮺�ü<�%u H'W���-��OkT�wH��D+$�,nY�.�L��~��'���S�7���� V%��
����/���"���,u�x��Y�
j�w���Z��� W���ܠ���4�+V�L���R��5 ������sϯ��u � '����O�J����3!rqH�H)ج���c�t�l��#t�]u��=B�
����\�Ҧ� b�vQ�̈ؐ�yB���]E���Qǯ� ��+�O �/|pj߀�&��j��PK 4�h\_��w* �4 diskcleaner/core/safety.py�[{o���_�b� ���K�Z> u��872l_��g4����H�KFV}���s)ɉ��D�1;;���,7�����k,xp�s��OĜ�<�H�f<���F��<�$B.Y�.��/x"�'�d��d" �2ɍ���-�+x�T&#��R"�O<�����IȲ<
����A u����k�Bp���Gb��y�Ri~e�_ �K�,e!�ꩼքGQ�.Y���%g��<�^��K�s�Uk��X\��SxT �:ý����z�މ���!�{��&�x�.�,�#́��A����^�&�� ГmT�=� <��G ��$JG�Q� 6l8/���.r>��|@d����VP�F� �G��=:d��A�:�r2;��� �� y�Z��槇g�8>??����$��zUcN�f�j2�
��?<;��a;��4w*��5 (c��W�x�
� c�����6�� q�s���N
�K27~W� ��!9У {Է\�y*�1��!k��zўA��� C�~p[f,ȹu@���Gl>�(�sW�8�0e<���.��\�pߧ ��$~����c�߶��1o�Y�ƏYK-Q*X`���A@�u ���������/N�� �G��x�ӓkY�%���>c'0f(MvĽ�Q{�4x�=h,��=�Է&C�Nlt)]w�^��<�c0���^������vN˝ ;�c�[�k[�l�kg�ʻ�jl{�N��Ԛ�����K�@� hnU�(r��k�h��"�z�t��1{� rOC��-jt�_���8� �ڗSB�K�Wc���j"��:&
H���;�Z��
�6�s�V�H&�n�`�,� K6�q ��3��sm<�Y���v�p,��uyU�R� "Ѽ���zB�N�}J�緢�&m���+�.����������7 ,\��V�T�k��Ȇ�_m*zW��e< ]1��
�I�fx�b�zm2�J1d+��7���+�b ��|�iL��� j�@�!�#�O�Al�?c�Yֆ�� ȑ*�`m�!y{�k<���]��U)�húб/^
T $��?
fm�<{�իԹ�j#��<�bKek����=�(,a�,� �=v���,-|9_����H�ZIgύ1�m$L} U^�?�� 99�u��vWV2��P�(Ы��n�a� %�D �4�͍/�7W�� r���*���T 4 j%����(ɽ����`��̢��j���� w��� �\���A+@Y�5�9Ӑ�k0�! }�Q
''˵��V�V������^�&�(�o�h�p�t�������
=�
jhr
���WW Ms�1��M�����F���: �-��'����5��1 �U�K�(�Q ���^E���b):��[�ib�}����`h� E�]ClNo�* �� �Eԭ%�����t% kP����J
� i�GTz�@�zU����a�s��e"�(�M[cO�5�
-�o��"_�'?��k\*�4^��pX�% ;� �u&-`���b�1%���,x^�-"���ȶ�B�1� �L�i6?��� �]�>{�� Р9�S �H�-C�4��<�
�����kg�Þ*ܱ֞2�'3�_��K��K?��7���č%��A�\��
�^�^�K���f�&���U��euT��e��0��A���{���5��~�G��,���ǭ��3 ������2�j`�uO=i��~�Y\ccj�û j�P �O���LB�5>S��d��N�g\x��70a��%�U ��4��5[+�ϴ��i�D�Q�Tg_�B�V :t!q n(�����|�˸��
/�ߡz�k�Y�S ��k�Kh��[���*LE��K ��נ�
�z ���
�D�� ����@cxrm�ǯ�-���߶چ؏�o��&^����g�ٝ���2����Z�3Q�k
�j̢����jo`_b)T}��ζ ���x|�ܽ � �qܭn F�'
!�~|D �� b;�=�s�5+�>d���Zoo�P�L���
{�,[ I��d"��W����'��骭G
Q= �Pk�e_��u���R ��R��+]���̳}���Y��� ^7V�)��9c��>{3L?���7��u���� -vӛB� ઊ���W^� 2י8��P՚o����E�DŽ}��۲� ����$�1�������" W�j[�F�N��&�*q�[�"�{�i�rp��Ɣ�-h=��9To�ܿWH�m ^(X�����.��i���;�E 9��EքV-�L��� �;KPI1�$���Wd� ���9�V������I�$�a�R�]���HD]or���\
4��2�x*��>�������\9����,X�����L���|w3� us�� P�bdׂJ�TEe�oFԙ�8�� ?��J���[��/����p�!OA���AlY �������}�6����]n�y6Vm��\��kC��4�{oj�'r���� �ʝʥT딵#9y<
tEFD�|��t��i35����� ��%b D�V��;��H9���{=���ꋫ悏4����y )������1 ��*G>�?��*�� �j� � ������b��*��� � �� S-)��Wu�@Wi'σ���RN ��!���� �ׯq��}�xU: ��a�D8 JLQj\�d;�c�ca�W>�Uр���6D1�4��U�P/"�<Ы����TZ��w�
��F[ �C:@(��_��S x���Am�1 ���u��k��r�y购�uC�{g�e���[��7V�<)��a�<��y��j'��ɼn
Jsq W<�jAݚt+Ŏ��͐�*��E�����}���b�g�ޯ�˒ �@ ��վZ�e� {�mi;��ۿ�m`�%lj"qgM ��� 9�����^o��^�ks�?�>�K�5)�ծ���@���I����O���&E��qzc@d'r���>hǗ��-��Ϯ!q ��EAn��g�����B>co|��q� �j���ge#��+��/�td�����ʖQMFpK;�V���7�Q��s���j���-�$ 0L�2�C���J?g�H�ה��W� ������ur��{�QbI���� ߘ6��5p��!��w�"���3f�dQ
"��w�ǚ+��PK 4�h\�\�� 'C diskcleaner/core/scanner.py� ko��~�8�'����PС��\�9#N�-|Ƃ�R����� ��;3|,�/�Np@�.KK��yIe< �^%�X���2��y.*v����Jd"W<� I~��,�J�G� h�,6c!�*تHSxg�$�`]TWI�k�f0�摏}S�\���)V|u#b� š��T�"L�J��TI��NX���}�0��s$��La^��Y�f�\��%*�X�_~x`K����5b�tRR �)W��J���*�`.\ �+��c�&�| �S^��IU�%�dbu��Df8��� ,�w�:�hp�z��쑊+� �]WE�@:�����4r4����8YH�͒m߁KbD����K��tMW�&KۋL� jKk0�? �
����T3�K�R��]x��)S12�&�v�
#�"_'� �uAUbN�w��r�s~-`�נR9/�Ms��ٷ���ٍ�߾�����g��?O�~|uz��ӈ�3�O�cvI
�xr��o�0 ����*�+�=Ýl��� �= �@ͮ?��-�c�2ɛ}Z�~-�M&؛ڴ��/�B5�N_�i6�T��[�~�?�1��!!3��>�÷ɲ�n�n[�T �f�FV����,T�\ߨ�_� �}kI�"���H���J��y ����hd�����{^�� �f�<<+���n7e ��X��B��w����4�7
~�UG18M� �l���������c~� ��h4�Ś��l�8"K�E�f3�?�����'���z��x���F�nY�f\ۙF>�<��\����a/�ky��g���(
�{�6U�~�6�� \O%Du#@y���'�p r�[&�yZ� #KO$U��0��<3 �� #��s K�J�q[J��a�q���:y���Zh~-�DS2c�W�z�f�H� �A�$�I�Ӄǧ"��4Ѧ�8��[���/9(t"N��Ga|YlH�1�q4�9E�Zp@ ��<��L~��$W��a :f��!���cR)� �s��E cld�\W �wE.�?%N��z42mkСH�p0�"]���!���b�>���Ð�L�[����N�#S8� �͂>d���oa �Hw�װ���{�k� �i钷 �������G� �,� @���%l�W R@f�K�6Q[6)�X�Z���/A�H�,��NI��͖E
�Z� ��SL���ᐯ�z��I� t��1��ܷd� B�A�'�Az�A�C���8v;U��$OT���e&
� 9;�{t��i��5 9 � �k�������)��
�� �4� ��
�5�)h�U1�@��.��x��q�< ��p
B~Ig�
Ȑ���[�I� >D�q�?$�&c�&[��@A �H6A~ [69驈�mT���a(E�UC�|��{|�!ȸ��4����s#1���l��N���p�<|a����i�B �q �g,��k?�5@��NٻЙ.@�O?՟hP0��G�ܵN1B�� ��.F����k*��ː�5��}$����ߛc����76IG�g(~����8��7��}F�.���P���`�
�n��0I� 4���.xd��t,�h�Ai�� @�� 2C +U�jJ
I����)�)k����Z�n`�����0IR $���u
��q�:��J��fSW�>��_@F�ޤ��/����Z�/>8:";���vV��W5Z�j�=�
LF�a��ږ��FBIx�D�5q�= ��H�Xo"���|�́ː[z �b��u���OBv�@fN�~"�sqo�brp
�A�
� 07昽 1jV;kyN�8H�)5�
�i��N�?Y c����r;E�k�(laȊ
�$� }����̩�\fݴ&�� ��c�k����m���)��#j>X�5��t�C7���oeGDQ*
�n�͚�&w��Bp�#���$���aQv��C���d���:��rN�j6��fm��K��X��Yp�Y��os�3�%,.�W��]�5�_�LS��G���d]L5�L��M���'}��6��:)AD�Rv3�q�!b�i����ʾ�(�l ^b &Y��;�$.+��j�fk5J����PY Q?�6U�E^8�]��́c�
(�`(� �I�!�2
7b����Ǚn��jο�D|��1�E���ih�V�i����p623�N�(<�c�� ��G��h����X��%nl���N�y����y� �s�Fj_�q�Ӱ9��<��͠�h�M���tհ��{߽=�c�� w��
��uwx�`x���� M�z]�q���S�F"[;'�ƺ30���:N��I]����DT�m"Ҹ#�wc>܀O��9*���J��6VHh[�� �Y{��nGV@w&�c{ �Q#J2E��� �U A����� ���!�Ddή�b9�p���mc��&Y��7�=P/�fԨx"a~W�נ|�iU����s�0��z�>51~ {j�7����f|��[���"t��5�=k�?��R��M�,�H�Z*K$��U�>��Mvc}�ݩu6 ���zdm���]Sz�TԻp�Ϊ(�Ѧ���q"��=492�;؋����36 ��XOOs��أn�K$�z{�BѾmc�����;� |n*�� ����}7���Z��q/c)V|#���\���c��V�[�&M�h
���D���:&:ހx�5]U� � �����=��g*�[�FT':���� 䅵�y��=ҿ'B����n��d�vb��& .�;�i%F��'�F�I[��t�O
������"��č�D�� ��xB�|�rэ9@QB�g�q�p�qQ� E��
rj2�М�v6J�ä��Cu p`)���z��dw�\��ij?�g ��v���b[H��B�&�dR�����ܮ�탨tЋ���6��f'~]d]��@���B��& ��y��'E�n�����K�0;����X�b<�q7r��
�Kk ��0�x��!���c'Lh�PP��2�F1�o�z��
n8�#3��N8>�! �S�avxXC���W��|#�y��ᒭ{�͝p>PQ�By�"Q ���Lk�<��ls ��bP�ۂ�^��B�q�� ͠V��P�ť^�zKhျ�$�CU�&�}Ϣ����_��u�� U�F
��h����c���|� ���`a>w �
��呮G���� p@� ��� ���$�V���=e�hO�om��u۾Q�ˠ�� �w; �#xm�ʰNfl��A}���n�M.����w�|��^4FS��o��u0=b� �M���rA_����61�1��B�� ��0�� �v⏤���_Qws��
e�'��rk�Ln�����e{�*
"��M´��\x�0�\rl��R�O�o��B�ۘ����h �vb]xJ�ӧ���n*�B���zL>��&�B�>�c�q�$���>ch���%�cJ�g.L���T.yP\65yf��ܵ��Z�x� ��^^#�m^?7�����)�t����x�������ɋ��������G*��^I&�MA�-z:�@����W�>�S��K9x�����fE�"�h���C��� e�H���>�>���q���o�ܩ�"k�_RV��O*��/� Q6?���U�>�� �d�Z�~��u�bݧRݻ��]P�_H�cV����^����+�(�* w���`�tvr�+� Y���v����q�P�<�� ��!<5��� �/f��5.����QRL�)=x�ڤh'tpO
��;} L?Ȳ��xNgI<��OCw�15 �Q�[%z½�i�e*t� (�P�uP����u:z�2#����!HG@k�^�w7$�sʧ\w2�/��J�4ɛ�ۅ Rf�w����w3�T���
���>Q��hۻ�'�e��� ���?L��t�Y�T �5g��qD7Ft��W�eIN:eK��?X��)3�?����+���O�1WWڗ�U. �,���9�Yb���˰�1��0H3k�k� �3&�
���VO?��j%r�?��[ G?yS� pp�-�������Q=�}���=�E!;�H����V@���{�o�?��U�2���ɭ�.R�-c�֠��� VHH�kѾ+�!�<&�_��PK 4�h\Աɶ� �, ! diskcleaner/core/smart_cleanup.py�mk����Š�D�uy��T�%���6�J�!�Fk%Zi��N6Ɛ½$iC���\�#�� 鵐\�����)�u�/�yfFҌ4Z�\/fW=��3�a kC/�I?�^< �0�� ��0 /�H?I)&�8������ 7 ,#Yߋc�v �˲0�� �����a���$��OH��o�t!O�(M�B�3��p@�J������>Ȑ��� Q��(a�pH�4x�1� �xX.��Ǵ� y�fn��-�OF��X? ���y���#�ȋ�0������O� ,��ٝ*�ve�|5��r�ڂV���-,�W��˅ i2 �P.4��ݲ�O �we�S����"P��q�,,,�_y�}�e�۫q� >�U����t��Y�E� ��̓,� ��ƹ�A�Iަ~[ܐ�a�I� �<�C \��[dY���[ߘ� �� ���;�Wh��^��`��y��Ą0��)D)=�u9���w�ԑ-�I�E.#���3P�Z�E^8�6"�f#�/ T��dHs}��0\L�. ���� �< �l�}H�M� W���G3�Q`����'��5�� �a����04�ή��>��]D�) �1��C3�Q]$) � A���=��i�LF���-�Ml�����$_����ū���++�W� ���1�>��Ѧ�!G���Fm���5��_�T�z��<�$�5%Y��ZAQ�z�����& �GZ�B
䅏�XQ�VX�U��aZ0�R�� gwK�b�O)?�8Vd�e��A�P�6SJ�|0T[�de�IL�} �к��jy�P������7T8,����vy
�
�P_��\ı�gj�F��n��뚥�����.�R��z娞���-�w�w�u��IL%@��Kct��%I̵t,`,%��� W�E���ƛ�a�9���FCj A �y�Mm�Ђ ?N����������
���� �V5���`Ҕ�,����7�hjZ��YmQ�Ri���jH~��
=�o@� �|_��-��r��Ԋ��i�,�b7����;� U G� Wש�����g6YԐ��S ��"� ��F�FD䟣N{Z�e։PlK:�h�SW�Ti��K��.���kf�z<^�)�!�d��87�t"�b��`U�=^��M
E y$�S*�$�U�ij)jYM��ݐ�.0��9����c�iɹ���9��s�_d1��<���*��I35UE��:&��nq������=�&'$�u%�R�QF5�uT-!�rpF2�K C� 7�a(��j���A�8�I`�� ��
����B�n�vV�^�ˉY
��ש.�����LD ��%=��e�i�]1����56�H���}�+� �}��a��"
l� =�%x| M�Czg �.��
�jo� �9�ԍ���k6��ү����m��5��Lc � gl�U%F��g����Q�rgR��-��N�&j�eX��8��@* � AE�A���!v��z��j+h� ��V����VYx2`.aXaJ�� ~���T�Ft�F-����q�^E�
j� *����p��<?�� �W�;�z
2�T� n�` 0�À�U?�0�*�l[��l;��L��r�))�e��٤)�P'���2��{�۵��z�)�iz�4�pm��� �b�9ֲ�����
� ��j>,~���`g_,<(q*����H�^�鲺+�V�� X�O�O�>���FO�6ϋ������{��N��F���T v|�hϒ48�c��6IB�U�y�&�z�0���]M�s���Ӧ�e�4]�s��4Y�����t� �G�M�`糖�jU���ة��Mt��V
p(�:hV�U��6Nu��H��H�: ��ե
���XQJ�8�U�iq�H~��|,�����.��!|`✰������c�U�q�w�hN6�C/^����鋠I��v�5w���m�� o��6��� �� ��� u��Ȉ�ث7z�1ȏș㪩����z��g/?�����ݏg�?���z���F� 1����Ç���|�݇]�]?x�1��G/�<� /�l �K��ª�e�� �c��\Z .-�d���K�ŵcV���;��0��� ��`��=�}]���쏟��}�����Ͼ�6�2���Af���#���4�bh�'O��>,��̹,�L�
�4Tk�9}�|����g/���ڴ����{ӏ�6���7z\w��
�.�e�\�fCo�~�n5,v3���FE�b�����W�^?;�5G�?@lm��W�O L�<�" �v?<����VGX������g?�RŐe�v�R�D�,]4��rjs���T�~r3�F�/�)��^<)���8�Nm�Q�F�"Xa�*d1����������o���E��?g3
Y��
~��
�|�A5����s:�LM�ݠ'��Gnu��ԭމu
b
��4��z@����@�9*����}�̊�~`Fh�tqv�D�TдȪC�K�; 9�$O`�KRuJ,� <�f)�����Z�mG�JX ������Ĝ�{p�^Y!�o40��C���̈́�uO�w� �g���=�3ܱ��¦�j�;��˿�Rvt���/ ���!`t��¡,mt!���fh���w��J�B~���uO�X�a 4|���-��J��؛�Lp[~�� l�&������{d�Fg��b��f7�8m�/����0��,� ��_ņ}= c�!H/g�i�%��$�Z2��'Ap���k}.��!Xf��T���Ŋ4��w��1�=�! O�'O� � K?
c ��0Gn=� ����}_b����s��4<�-�%?!'��|�>������ ����ؖL ��6bj�@ φV �$�;��� RW��n�ŧ+�ռ=S���=� ���ڷS�m���#و�q�[�8�?�VJ}�'�w
I�g�7�w����|�.��<���
��Z���h��qz�Z��-v�Ys�ݫ��1<��%~�~�日�Zq0����C���4�����uh���O�J�����+��9�� �)�Ѹ ȉ�#��$�ْ>&HYX��ݝ=zJ� �>����ׯ^���H�N�����7���5�PK 4�h\�|�G � diskcleaner/core/__init__.py}��n�0 ��y��3��2�N=L��v���
����I}�h�B3N����N�,�Xa,��ғѠ��xc�N�cYH�ښ�W�R!h�;v�95���}� �hS�
����Ʀ=),&�h��V���&]��o�����Ú�M���h!,�;�~�Qїv��!��Z#�9ь�F���6y ��� t��j���0EC:��'����~�GP?�7)m5��+�CT\P^��8 Z/n�,ʠ+G��j�z!�+�|0�'죜�}͝��3idLPJ�¿_�>/�G�h�H �pi��V���&��f�Iz�Q��<s�X��# _w�}⃘� $~� PK 4�h\u��L K ' diskcleaner/optimization/concurrency.py�X�o�D��_1Z��f)�H��T=�D����&�٬{���]�JT�IDZ��VPA�$�"Z)�L�IN�x3 �ZO6?}H��7�}�{y�z�^�aԉ8'� S�D|B�2�X \���t�'.��Z��2
��q�;(`� �pǙC�P?��Է _�c�!l��8[q;�B� Ze|�H�, �9��l�[NBq� �#�FA�V�5��a�˙_��F"�EH[�%�� է*
ƛ�_|�����K��O\G4�l �`�V�9 � �%d���K����u���N>JE�0��5���I
M�hɵ�ޟ�\n:H�p9lhù��rfn�d9{���&��F
{��U�e�n:��lۥ��m+$^��@����Ja+<ӊ��Pɾ������j-��rCM�2{J�m��B�_"�.�Jk�(�x�B2�TD ��+ ����B���Q�V7��G��rRR=��&��`-��ݣe ���R���WL�@�k����Țp� :�N4����"?D� 3�(�*eu�]?�SI$p@E2;%X �4rdwl*:��<ri(0u�����v͔�s�j��]���鬠8� %݉0t���-� gG����t�������d���8��v�~_{}0Yo��-2�N>+�<�y�t�E%U�͵�ڰ�Χ��!pYa�pس �Q"h'��Ah�\D� ���
�_X��nv��Kf�Wv���6�d��t��G��mY���"T�,�}��l��M59�T�Sw)���pRA�|�I�E��i��j�KY&��0����VC胚A -�+zV �v�Q��;]��v�b-�u��������?�~� ��'~��迃��͑%'�|o��ܾ1��ڣ�o �<<� =9>X�E��� �o�����'���Ժ1�,��.�0��
o�Q=;b���o��ӽx�_ ��0���d}� \��*D���������+ j1�m?>�f�Ӟ�M�� �|w\]bi���9 *y D��Q�!�C�_[�0��Y�M��F���x�������vB&��]�s�$ ,���tF�bWL�E} Ci�+���q��p.攌_���������� �v {��B�,����:�� ��2K�h�?��s�H;��t��#w��Ԁ�T /����%���
�j��ʫ(��Z�^�f��+}�c��H��r�0�T�H�RಧJ�s�d�պW�wDS�C�`�)��E(�"���Z��L�n�jU�i���/J�9*7,��QI��`��,7
�-� L��P=�vL�*�ߗ��^}a��|���`���/��g��My��b��� -� | 9�d?���J�S�Fm�Qt��PK 4�h\���T �C " diskcleaner/optimization/delete.py�ko����B�pT��J�|1�Cs��M.A�Cp0 �"W��� ���ޙ��EIv�W�BK˙��y��r4��ߵŶ�7�Y�K�uŲz��+^�bzv���o�����'쇴�6��7�j�6-[★
`/ľ� �i�e��]�� ؐ�mҖ��zJC�P����pF@�Y�\-�7��ڢԿ�M�Ӽ��f���USoakU�5
�m��ڮ�)�O�����˯<�ں� � �ҘK�<mӬL��͐��U�Տ.� ݥ��,����) �� ��_T� {Ud턽�D��B�o�S]��}ꀢ��3Z�ca�K�/�|�U�N�z\L��������ū7 /_~bs6ʋ8=b�Ё_�48KV�h�h�6 `����%"�>+9a��o9kk��ز�l��w/>�b�MR���������G.��5�?Y�b�&��!�`�~���2.����C㫴(y �u�� 9 <-���8� Z�n?�e�<_��]�UY�r<K���4��
�:-���|S.rЁر�'ߓF\�'� 7r�/�ꖣ�� qPE�=�\5 ��b���T,]0�8ٍ٪n��G)������E�� Ē�}$���K��`��e�˱(x/� ��l�h{�7bӰf��S\�kp4� <�Fu�0�h�8i<�Qb�V���T�� (=�U������c�~XM�Xo/��A ߀r��@Zюԛf���t���H�\p���l#�3��Bx �kD��e�~DUPq��?5�k��so4��5 �p�Nj�����_7V�Fצ*���D�Vt���ݰ�VV�#��X)�s�4���Z��Ԭh�`�(��],H&f�E���&��r� m0�� f��`����E/~^4kq�0*X��g����r�ODI��
y@�*֠�� �¬ �_F�8�FOg�ل���xsK�7�>���s���:x�#x�}�2m�<X��{:�}����N�!�S0�KP2}�J��`J��)v� �i��☢)� ��E� rFt#�B������l*�V1�\9]tŊUu��w&U�ʞ;q Hr���(iK�v��1�! 5���> �`� 8�B�{��<
���)��X��Q>��W���9�oAj 3��J��c���_�@\n� �Z捁�?߳ٽ&T&k�(����roz���(
@�PҪ�5�U[ �Э��F�u����39��:C���nK��7�~ �>h�j͓���������H�O�\B!����4�w]0�]�ck��z�x��P���$�@KK� � �?v�PN�זWy�2v �Z.� s�,�?����?b^��j�J lsҤ�Ⱥ"� �A!��q�s/�
��E��!,t7� sKq�P*1�'�V�-��?a8��w�;?�-�1{z�(����q�zǞ��cw�p:O�����WF !����� ePT� �BMJ?��j: gSh|�d^��� ���h����
�ʵO�=C�(|���]���f�$7� ��0�#
�: k1�y��t#�mc185�e{1(+ �.���+T#�y�2 [I����r�i��'����9���o���\���r8"�ׂX��,��V?z��Ԟ <��a�H��TRA ��m�U �9o���p�p��a���1�nj�Ӕ�%�4�ߟ��9��
C�n�a1��E[T ������S
�a�}��pl�D��+��L�M���F� �k�w-{u����9g1��.S0 ƶg��DP!y�$\���i�mA��źf,��s�!k���&�UP4I"�A'g)��y�w6�ˤ�5b�Ds7��cJ����?0�i3���$g:-�� ��p��n=q���[�g
���}Cv��� �g
�<4�*t��nSx*�dzs�ñM�.��� od
����� �yɑ�����v�t�r��-y�)B�'>��m�9��7h�X�;�_.W�.V2<�q������"�z�ොDd���8����I�`���5�nv|8BʎM�i��D���}�K��A͐� �3��Ḵ�z�/��U'�؉��A�����1
��X�1�Ug<$�iV����h���du�n���Ҁ�23R��� ��q��[�1���)���7�p9W�+V\�Q�x�f �j��� o����&����T�IXK3�����I��Z�E��(6[^�%��J�{�8i6Ex�������r�IE��dp�>�M�&B&ߗ��( �ϼ���d�PrN�;���];��l: �w9 y�ĺ �ø��b C��
!�&��N�nb y#��ER(*vU}>
� ���s3�O���(I����P�f�V��ւn�x�a�'����9�)I�0��3��:�m��� ���U �$6���'� ߣiE�ǻ&R���)�j��g�ü��m���c�����^�P��v�v�u�%���q(\���J�Ң�)~D��*�&p �������>�g;=��8��6�iQM� XZ�
�8`�.��\kW�g�ų�X̊D�6�z"���F��t�����b�n�ۧ�U�~�ȖK�ŵwD�Mdt�'n.D5'~ ��ĉ^�q/�Dn�|띊ʄ�Z�{ � �+��K0Ӡ��L���_�x��ʫB �;���y�����]�8p���x�W$��|so�{��,��5�YԵx�Ҵ��e��I3�@:�㍏N����X�{�
�$<���- ��bS��n�<�Q���/����q�/��y�A���̾�Ȓ]����Or��+PWl�M\!E�7�py�K� ���b��|�4�G*0�q�c���_d8�f�c��qA�Q)j�Ԏ��EQ�K�9��R Z��6)d>���t��O� W]9Q�e5J��m��he�*��@�E,:( j]�� H˨O��l��DW����+ޛ����d��`4H�D�ַ �:�s�H4�y{� t`�tFi ����G
��ު�AZ������+��P|:�9U��M( ��@� ˩���jp���ܠD t6Q�2{Į�)1^�d �� ���F�Ӵ��xc��<q���CP��I��� ����h�FT�[�} ���,�M���5+0�}bfÜېAm>�I�������
{��Gl�([8F{��[��:��N��� d*ގ��i���U ذ��T u$��Y�4Dz�`�l�a��T�;��_ �:�;p�"��:J�bK��
V�ŴJ�79g#�� s|�� �e�� $&� ҊM���<��_cP� �=N��٦����E�}�đO��Z�T�
�tY�Qe�v<a_�ۡ�� e<yC� �C �"�C%��~(t�~N
���B(Q:F�s8������MG���J ����ծ��<�wi����� �z�*��P�%� �*lL��"�*��; �T�r��K.������{ �;0�_�:��ɏ�`��O�=
�7Ҩs� B�#��\7R�>�� zn,;(��p���$��-��j!#����Kt�w^�����N�²� AxZ=tN=�'��s����/k?y+�k��� �H#�����u���q<��oJ����o�3�cy/���ay:����w U�BT���;�����f2u ��]��:����jm��s)}kD��=�W\H�6 9 �Y���i�!� ��r��+*a���l�ݭ�-����~���;�>�� 0z [z�(��!R�3a�����i���Jݲ)�<c��:pML��V�[G�� ��¢E�nЋ������טL�h������ zO9��+/V+����ޚ��H��ヺE&+�P�ڌ��ocSD=�%� �|�gi�"OTT��7�m����C����G����^�Zb ��� H�b���UWI�b�.mR�o@�}� )@���$�p&����6�R���C�1�>vUW�S $�N r(�: s���㪇`���PK 4�h\�u$w0 �I diskcleaner/optimization/hash.py� ko�F�~�B�!ROf��PM}I nru�� E�,��rIǾ ��ff��R� �w�K��ݙ��y3��p�~Wg��_<e�XlXRnwM �YY����E-���CU�f)��){��0떿����K���,�!Z-+��C\�y�s
}^ISU�ngK�~ ��u����&Knخ�kz�uY����Yל��扚���Ɇ�ػ_g ~%p������� d@[%1ȳ��Y
���T<N��uUna
�vLA��R^���YRkMX�n����p!>�e��'M]V�%b� �\ ��8�c!�L�HB���5��O9P��;��90<^�|�� {� ���,�|�~��47I��WQ)���"I\��D��b]� -J�/��>������ >�b��ʵsZp�\D�~��3Bn�7��5cYQӯ�l����#[��y ���Y��l�4/�.N�lK����2N���cv���/��B��㹗4���� W
Tq8ӂ}2h&1���:қ�I�ր��"����D�F ��5L4�q��@.�qˑ��
�ᔝ�NW i��#��/��� �� Lg�x ���� р�$ [�kM�g Br}/�;e�0�K!a� ���O�{��r���i�l5����tJp�1�,��F������D g�X�W�\O���&��S�����.��@����r�Y�\�`��ί�*�7[�L6g�H NX�i���k9�>��}Eƞ ��oa�,�a��U� ���Z̼Cwp�㳿��b�l�M������� .�l�-�b{���0I��RV_�� ��Q� �$mv�|�L6e)�� �̷�?�"s��{�֗H��?�㌴"]r8�0k��T) �@� ���e���* �G3�+�ք7�.Nyb ����.[���i��߁v�R���a&��w4��P
J�'~��އQ��e����8�՟8x<(�{� |iY��J�՟�C7׃wp�2��K-���e�����i`u��oAW��Mԕ��4�N�4�n��U{s�i���E�ѿ���.�������嫪Bg��{���DI�Xf %�Z�q�T�8�3l}9�� [i�@W�BQ3�V�18/l=kI�� .9�S���
�|�Β�ɽ��=#`0��x�<ޮ�x��R�騥
��[\"�f� ���b�&��4����7��j�S��rQ�y�W�)� r��n?���J�� �P�����%yh�f#��S���������c�ʱ�d�b �`(j;�^�ׂ�1�:" ��� pp�8��Y�a�k�����K �;^�J�_쀬�13Z~���]�D�~i�+^���U�W�*Cq���Z)
P%!���R��U!���Idž=%���� ��7_o�������� ���ƀ�)d( � � ǗԎu��Vݳu,j��o��GB=��CD�� W�ΰb� ���7˳�� i���Bdɻ��0d>�U ��oz��Ñ��rT�x�tH$ B^� dtX ���jk���)=�y��?z����#S��V����I䩠j'�^����R"6߈����匿�)����`���� ��W`�tnkJ�
��/e�{����N�}L���aM�|�Y��� p �eJ�W��q;��F� �dN `y�p�Q�k���b�ѹ��p��t8 Hfj�۳���U������]jtw�&ȣ�
�\b�h'7s\���/�+��:��Q�� $S;`�5 "!="t�:�ZƘ1��X@�
�kG�[
�0�k�e���R"x�?}v]ܘ�y gP�ӆ��)� њ�%�qUN�e��f`�!�cqci�yqokʖ"�Y�H��^�F1��t�ȑ^���Zz�@��&LZ�>,.���5]Z�e�_qђbr�0g��"j��Hm5�J ���qؖ�� IG�`y����Ѵ�`J����uB����o���uW7�z���S��Y��u���1�����-m�Q?��O�3T�j8��L��벎s��Ul!�{�`8s�.���Ի8�X�iv�[ �����c1�g��������k�1~�V�g& ���T�ly�)Skc�7��Y�b"��m��@���br�Y+n|c&�����7����oL�p�/�:Ԧt�]�^[��q-y� ��b���Jr�1�:� 7cc�F,��� ��bF�ZV�7� ��d�u ~� ��r#����B��^R��ʫ�U.d���n��`
�S3K��e8P��p�ч�J�{�C�Q%�Hz,������)Lގ�q�]�G�� �&T��5e'���J�=���+ w�]�C�m`�&�%��@ ��A�ݔ&���{�j��W�%rI�e��8���c]/M�W�@� ��;�X
,� ��[ao8����W8��/�{v��N�S�7j]��H���� D��fq��'8#-h�`�U������Z�������]�7�,���#�f����Ѕ4~?�c���˳T�3�0{<F�]Y-��N��с8���U VQ�rX�� w��1%�K���]���F�w����FB��o��t�P,ֶ�@E:k&-EDf���:�3���pϫ�x�� )�����TF��Q( �2!�+L��/���h��� ��V�pq|�f������J����M��H����J!t��a���R - �aDTz!a �� �
~����jF������+Ͼ�i�R�:�_�f�k˦M�Ɓ��8.#��X��p�G�X ���rP�d�N�U�c e�_��9�c ��Z�kM�P�M��7��9� y ~�ܶ�E��A{�MV /��kg�����^��R�b�n��U��;:@W �" `F��:?�bT��#��� r�%. � �ഋ��I���
Z<��t�Ha�D���``�Q��X`�� �i�7���%~�����0:r�" ��i����>զ�}�2�!q�
ʏW�k22�.�o86���ҩ����<N��<D{��]��$,��Ѷ��I�j�g��vS*v�h s�u�D�p �_l�MY ؕ�
qo`7Wrb�gT�Z@;Ң����,R�:���Lq�@ě҅� P�aD}�� ��ӫe�b1Іi�4�� ʳ��{���0�-�v�.��vF�D�}2��ܶ�~2 �V���JoV��갏 {��~�w�l�W��Y�ۃ�ғ(�'�$.H��g6q�K�ʾ��L~�����7�sE�@"��ñ��7����x�]���h%y�r<Z)>F �Q��(�EX��K�[3��h2�J Re��Q9N��<� �M���GtN+U��X�ˆ 'Α�+�>��"f�/ A�
�6ET:�:d�T ����_�%���p���TO҅Li\�|q-v^{�_�%����MI�k��O�]BU�wҺ��b�P�t��� E�̻(�=�Qh֢_ᕈ�!��#�l����:����+�}��Y�� o���i�o�*�� k�V� �*+@�P�ݷ���⼾�:�R����?b�Ve�⁅=9����G����:�⧫-}����5�d'�� �ֿ�L�wk�ɳ��<���EX���ʫ;�� �n�V��1E=���Zn�k����k��f���9&��YO�u7�� ԇw�]u���A<,��7�!K
�i�p[YQ8���td6:�BDsm��S�7� a��G�#䦢�ZxO�L�� sY�ߣ�0纺wߒd��_�{�N��]�|��f�R����ngǧ�@ �`h N�� �z ��?;R�ל{�eZ��1hSo� ���y\��-��mhkG��9)B���U�����GTJU)�s �g����: ET�(�u6A�权n3�5f<M_�&�J�S �ԧ� �ȴz�Z�q�;�pha��h����<b�6Ͽ��r��8HK��8s\�`�ە��Q�ax���E��(D }O[I��4^R���N�����t���:���N
�{ {����oA�+N WK�Q�u�8���q���+ҹ�����R:F܊�ۗ�����`M��G�ķ���v��GUuh�������������o��0D9"6�-����y8
� �4�[V�CZ>���`w?�7���圑��Svֳc7��Ku�l$�\@ā���Dh_1�2��.�t���k���-�W}{f%eQ�N,�u�#\�VX�I�z��f��� m�n��$BKj/(�-G�H��`��mf�i�U��l��2<��Z5J� l]w��.������ɰ�Od+�צ�s�d&3�����ɴ��S��fO� ����mo������Z���\!7�d�>�V����nD+p�B�A�]��=�B'ao'�Lt�g�|N��_T'�q9����Vl
\�N "���NÒ_S�D�$�`��vi|��<�����E� � �l��� ��������� �
PK 4�h\3K�)H � " diskcleaner/optimization/memory.py�Yo�6�ݿ�P0@.�@�m�\�u���I0 � ����D���fE��>^)�G�M/���� :cRP��
ZfeY�D�LQ�K�$)����=�
[sؓ`+F���p����*�%G�u��h: G� �t�bEY�������`�@)�p�c��Z/)Rօٺ��N�#w����U�C���u<�plK�%D$���[�G��6��f���F,�O�>���G��ob�|�ί�x��rA��5cBm� �X��y)�T=G ��(丘��"�����##���ik}EX"�kNR{��HX��ѴK�˷c4 ����x �B8A3��*+�Q�b8� ѣ�uE�� Zb6���$� l�1
z�R� Z*͓��O5�D�ّ�V~�d��8)�8�$_ �l�v �;;�aa�*��f8��Y+��,�[�{��d�E`�� �섈Q�w(�7����y�#4�����l��T��t�1+�ڱM���
:�~t�'8߇��� <��q�sN', Ī�C,CG:��Nޫh���T&�ݲ��ZN����凱�˪b/.��%+^WY�q���%���w��j!�<=WYv����HBd|؍oD"_���H2�b�d�y��]�9�Q�"2�HK4�Ioo�� TRg?�x,~��a�e���@BQbU�j��t�b��p��O��C�i4~0�#I>�u��u� 3C��]���B��'����̰� ��݆X�@�ߖh=�ely"�c���7 o��~���Yd9ُ5��&���˚��H�T8�I���K�G�Y����r� @��ˉ�,;\ن���o!��ʬ^Mm�k�F-��� p�6 �HW����TZ{��ɥF��.0�K1�M8Td�(v�@=t�����u�+`�~���v��?.�m����5�����k
m����d@à��;E)2h����C�a�g��-� ?33�9B�O��������c<�\�7��-%[����6��|^���d�0�]M�� I ����Õ5���kp�
�7�2�4�U�Aj
a���B�@�Jk"f#�}��g
��I�#S��"hm<i��%�2�� ����U��3��~N�"�~�ҸB��� �i~��2�B; Q�/��Ao s-��f�k�;`�Πe[0��=��
e� ?' %9��,�H e-�EE�!S�C��P�<Q��-��V�NWp\��䙲τq] M�֫��$�o���h�����.�p�� ��;R�͡�9�� ̈́�qی$���b
2�b�>���� �"'eE�#iQ��X�/������)z�ȫk����=�|�:�6�vA?B
�:.!�J�*���c�]:�aҳ'�cuN��ܭ�+vw�kIC� �>�.O�)��DwН��p �)T w��b^A`)>($�2:F���O�;(A�+��Z��y�~���N���^t��&x�p�R0Z-.�%�� R7 ��\��amOܐRt`�����:�YWlk��ܾY���x
�g����td^� <} D_Z��H�~ ܙНV�QS
�u��
�
<X
ܹ��B���;7A쇮K�{�R�κ�Ӻ�WlM�n��2�>Ѭ ���і�ӷr�ؖ���U*<j�� �+.�&�����rq���PK 4�h\\��g� R $ diskcleaner/optimization/profiler.py�X[��8~ϯ���$�N(hy�T��� `���ʓ8��\��f���9��v�B�<��}�}.��c;���#�ʶ�i�3r�ڒW����n.�>�(����� O�f�� �@
^��c�$-�P��F�^@/ �m+e��DjpFE�1���ߕa0H.� � �E1����v���ʮ�I�6��ˊ��gZ�*�c��*��yE�`
MZB> �S��'�����~8�5����SR�� �'���������T�� m\H|�A^3� ��+"d��d+i�E�W��Z*Uk��{������'��Jur��m���\�h���~�?�ғGA�T0Z�
(XI�[�{�M�ʔ\�DS�g�tL�]C���2~D�l���"��3?{^ łij��}ٲ<Z�N���g�@��� ���I�>*<�nȑ��"�u*U1��p 3�t��5h� �gy��<u�2���h�� ��D9��� �F�^) ��k��)�Ҧ��ȄH��Rp�@5�7*�77dM ���v� �����4z L���S(�W�ui=01W,F�� ���� ������e[�f �RA�
�YV�oL�*��7.�C�3kх�is���z����
4���I:k�%, �iU���� �,��D���b��)L��x3x�eJ���ʰ<Pד�1���^;I�Y�D?@F��МF�al 8�����@��H]nS��a=�j]�����}�%�Y@����|��� �=|<����a�K�<%ϖ���"��a^[����$�r�������`�^����#K���W� f :�Uq��F�Jjg�� �n�ia�&� ��ލU ������M3ltRn����`(=�b��^�g�����63ی��utp�B���4Kz rG�����A��)c���xM� ל�P��� �n|o�C�k(pO²]� ��`��" �1�ZM��Fh���g������o��_�3� � ��G�oKr�LL<�pQz�D� 12_�pew�� 9|ˀ/��8@�8G���1�b6c�`E��0�5�EA!����҉�F��`��cC�EX3��*g�l�H��b:�#H�q~�-'���D) =���|�!�t�u�#���:��tw�\_�A�8?'��g�`G975�O�N��ӱ�>��`��9B�ęg�\ߚ ��?? �?�
�g������a[���� NZ>UR��4�Mo
M�f�t������`��ac1�����r J�_��gVt���,�L F��g������E�%fY��P�ss��/N$n�^GS
��ݫS[UX w�U���S6��U����%w�1�_- T��*4�@��dt��+��"kI� W�IB`2P٬._�� e��1r�/��ʒ�O�a�IQ[���6 л�B]�L4� !��?B:�
���e�3�� T0;� ���fܐ� =C�t h3���oں3��P��t;�a��}VfQ�ߘ���5K&�ݔb�=��q[AՒ����m�fm����n��0�u�7E~�N����SЛѻ���'���q�v�v<fS��s�P�s���H&F �k]�����~E�7�n��Xo���{���QM6�~��|�(� �g�
?��v[��>�yM�Nfzi��m��F �)�+�(�m����Zq{�x �"�_! T ���(���<��o&�<g_8C�>��-���.
έ�At,g��o~���ꐟ�����Z�oEё��&�kMeg<�Ļ�p�f]�c�`+��Ø���?͕$�N�����q�o˛D��F�PK 4�h\�3� �F diskcleaner/optimization/scan.py�ks��;��NI�:�N�v4e&�%w��q9Mg
��E�;�p��z��x� $ 7�� �pX �~ ����:[e�)�s^Yq���j]��e2|_��Y*��������wа�rQ���\� %
�x���$tzQ�MU�%� �l�:;����)L�f���e��Sثb^�@���/�CpV �lM�o+ d���fK.�yvc^�ea~����m#6¼��8�![���*W,�5��\J!���e�����z�y�Ӛ^�ë�Po�H=��M���s�u&�/�2
����R�c�d%VH=�z{Sl08b?�c�H�e�*�E��b.�u�eS�rBo� �m����M��&| _;$�/_s�l����wV.w�B�c� ����MQ����a�Sj�K��L���� m�W�q��u� ����fP-�����N.gkQͤ Ҥ� B�y-��>���#���~$E��㯈�W��&��kEM����! ���9L�Jԛ����l��KX��bQZr�K�"�`��܀D2E�ʩ�#<���E�[�;�fɮh�N
�|AOo�%�%ϥ��8�G?|M�Y�zY�vn� 5�<�J;Ϣ�iICC�a� 0�`Z��Ï�<��[���#Y'�1��� �J�-��Z��ل+��kOC�.�����*[��l�k�T��5H��U�m�4~�i�����G�������$� ���Ȟc�s��2�?��דڣ �A�����Hհ/�D]=b��^S��2�t�
qG� �������w�M��.Q�,�Z.K'���W�(��v��E�|�����?T� CA� K���
�i���K�Oa3}I9�n�W�0�`@�,$n~�)���7�J��0��3��Bҵ�@��h��,n�HGAX$�nߋ
ݭd�:���� � �\6_��kQ��gs��
,�g� �ٌ$y�
��| P��~�ρ� �H|��n�Y ��v��#!�:��# ��9|�24:�"`�KB��YL��=�l-�{qSs�[8`�^����D%�V� �z��XA���u�ق`q�D<BG9��k������R$0��[���^��zؤ$��P��ziDg(��12d.��p�g2�6�n�f��oJ4R
�e������� ��������CY݉*�+p�[>���`�^N�� �
>u�
��A���S��sG�EU(e�����v<n�ܷ J 8�����?7���A�g�<$I7���+�7��)�E1B$�{�{Ba� �q���9R6C��eF2 ���>==힙�8P)+��
C]�f�:�� ���ʻ�$��
d
-�;f'l��h���JwO�OHUO���nX� @4� }���C��џ�# 砞l����� :�U&%x2j��5F�=�����M�ޞ,AgO�
|A�\��9�bg� ��tN�������6��>Q�G���sA��&Mj ��%QK��,� ��h|�Or��v�<����5�x����nE=�l F^bU�w�F��!P�*����_ˬ�;.70X�[\JB��G��g�݃ ���]�rW�� �O�a���z4�|͉���k@yF0�� �D�!�-v��W�4��4OPh�E lQ��bW��q% լ����x>�/t��-��G M9"���Dz!�-hYu�c�]��ZmXU�����1�=a��Љ+����ͪr���qu"w��� }*{J s���^��k,�蚪���[W��
���E(�J�!?6�+HzѼ}W^�f2��J�t�� �Jų��{�Aո �z ���9��������ģ��po ��
�V�S
��n��D|����Y8�\6�����|Q-�~�
}�+�>X�&���4�
MG�Y�������\93��)��Q� L����ģ�z8W��$D �
��
��� �|��E*S�S�Z��u^b,�Cݍ)���ԫ%� 5�I��ڄӯ���w� WF��<�6~oA��Ѥ]g����d�
d ��읚�P�FU���WՌT���+�����t��禧��E�ʹe��oz����F �q>
U�����j�YWBi����U�^�� ��j�#��.Qֵ`�_Lr�!LmuV��;�R*q6sܟ}x�+���1��/Q�M���i��S5丣eO�ڙia���+���Vp�&O��� �q��}`�uVlD3̀pt)�3�`4>�)2c k��D.�M�ٙ�y$R�q[�� �H�BK�; �5"�S��s ��P|̸���FNwgl�[wRjכ�cϭ��w���)r����v�g�� U ��E�<zwJ�5��* ���=U�4 �]�j �� �2{��)�F��n��.�z�����fQ�y�0��d�wrJ[|������C��Y��J)�m$|�E�6 ��&�ૡW�ꯌDp�\C;4T�� ľI��ln|C Q ZG}�d��W{0d?�i_ Ă���7�9��sP|<�b��O�OP��8IҌ�^xO���D���y?�iW�`h���==_���#5̈́��4���9�N���HoT+��cp��v�6 lg��]�ç�.�� �λܫ�T���,� �mG� ��q P67R�ڟ?a�¦Ӹb ����R�F����ۅ��r� 3�ɾ�����e�,��i}�$�$�*��dj���&��l2 �j�ծ�ŭڕ��m� ^��0cja@m�� No8t7����Z� �HM&��
Um�`�����6 @ !zE��q����@�'��^�trpnlj�"@��Ƈ�у�C�� ���M��� �֧��>yly������#�#�3��!b�:с�x�;uHz3ڍ� �}�ߛǸ��z&Ý�~M��'~u�?��^�=�lv�����WE �Q%5�h�J�5�>��z��wq���-zӎ�����i��p��G\��G��"�ʺ�G
�p
\���� �_���������gh_g��;o�`����Csm�����7���;V�W��ݥ����"���ý�.��R��e6_2�L?�<��|m! !��8��jQ�-����������/^�t~qP�XY��^����/����$l�����d�ǿ~9��r�k�}:b+>{麞\n%�}�:��x�
ڒ�uY����>���᷅$ �i�|_�Aú��'��:�_�z
��1�Z�X�
�p�������MYֺ��_�q�헑�N5���i�y�jS�qn�/�@��or���
�Q����1BVG���9��4>k;��91>8�&Qr�c�TGu�XN=C9T�HAϢwl�P���F��b7�(K��^n&�_áv�� I{fk]"��xO#�KTd�h��(
(p��n�����K�WY�D�i��(A�;���*��٣�>ʏ搖D�������exqf_��㷊�$�4_/ �U|�Y݀�(�����4 ��Y7�ga��o�����S��m7��2��}5�t�u���{�c���W��`�&^� ��*'&ä�H�c�v!1Sެ�m-�:6�DZie��f�=ـ�l4���g)�Js
�/{�^��!unZ���N�2��
ڨ��[J�q] �ٽ�w+�I����m�������q�ɲ�8��
�Kx�/��zw����0gZs�?I%Pn�I��w��4u۠ƻB/<�������S��s1Z=�Lo��խNw���k�,}����[Q+�-k�H����&1�d%fQ~]�3 Gx�����M��\����##Lݦ��i�J��JM"�y �m<N��1�n� 7�I�"����� �C��W=]� 묉�~�ުF@�v=��f�����<�1����=(�>��<P�=N:\zS�U��&�Ѭ���zȼ�%d��wly]��%D_��:2����j&����&Gf�Ӗ�Wv�� �la� �"�Ff�n_mzD�L�&D*� �i� �B<���-V9[� \z<�9Y�����
8a�jH��E ��"jJ�G:Z����˛w�H_$��e��^,��Xo+��b����hq��-��ܽ�Q���1u���;D�����6!�,.������|�ݹ@#�kQ�[���۶jT�&���V����=d�p�v�u ��E�[ �w��V �&*�o`D�u�f�S��{=.��g��ʂ��wj�J�Щt$ �f��:�n;N���Z�����P��_��a�ijy��wz�.�u J#�pI�u/��Y�kO��߶��,Z�g��o6r��
������n�~e!��8��C�Z]Q4�}��j�EG�" >�g ��y?^�K�qM-��1c�j����3<|�}�f��P#l�Nh��>���m����1��˛����A������Z ��Œ���:n���!��0��Y<����G��j��g��_PK 4�h\
��rG � $ diskcleaner/optimization/__init__.py�T��� ��+��ҕ���J=�[��C�tӞ�*b��F�� R�� C i�x3 o��s]�� �58p-����A��N��x������I(�p]U?zicxDs�
X&��dڭ��g@h�����c�Ğ� �.0+��Rw��5�`J��-��� .zJ!t�p�u�s�3a��;��������t��(U2` ���]�ߨ��a"��`�v�v����Vv �K�&Ū�0k%� �ElK�� F��ҩ8�� �����}{��� �Ռ|�N��`�r9rp� t� �g.ܣ���96����ѥ �QR^��"�� ���V����Ə�r�R�ަ"ϴ �=G��X� ��i"��� �Z��"o�ԡ�o������/�U�v����ts &oDHxѭ �� �2߽�K$�X� ���t>h>���HZ�Ǫ: I��}b��z�Ez�<� ����^݄�(1pk�)�T�aX �0ӝ� !����(i \��\� [
�Pв����8��8�0�s/�+��S�̒��s�u�/"M��~b8YkaR9]+,�M��Hrn�P�n��/@���/PK 4�h\�J7�� � diskcleaner/platforms/linux.py�X[��D~ϯ�$�ܺ�K���UBT��婪�Y{�L�x��Ih@E �vZ��*�"EP!h+��J��?'��s�Nb'έ@�̜�\>�s�-�ʽ�����
��]n�����Eܶok.|�q�-�r�Rt��� h�
���K\�1U$6����Q]������MQ�*�,0���D��+E��n��:�WOs[��ҹ\����Mo� ��� �:r|����k(��Ұd��nǬ8�%u�kGm�`�@JǍ��J� �����#O&bO������*� 筊nV�X������H�y_1��v�ن����U�n�٥ hƭ��q�l����݄$Ģ�c-�qL)/�4��$%� J���'�A� و"�O�8m�
�o��~D�R�#�9StGj^�G� �!�h��O�i�G~�U��ղ��Y\���� X�_�m?C'�]�O �CՅL�8�B�C�3 � �0�F��]�Y�I������H6�lq� i2, ![M �S 0��MCzR'N p��Z��.�N�L�s�vkۧܛ���RA�jn>$t-����j��k�t_� =Q_�� �B��
DF���J� �̦ {ՠ����ď�-��`��w�N=�#j��3�p��:s �"�\�tX�<�@��� VkQ�k�S�f5 q*�Q��PL|�̘��,>�j�j��LM�K �G)�,ć�ulb�l���;։�s�+N !(4>*��B��� �� 0�ؒ�e�>�~e��������Ͻ�/�?}:��3X�u�w�8K�䪉`E�L����@
�����:{2K0��jxj��5:ێ�^�K���jx9�ӊS�d�|*���S!�Ʉ]����������{Ov{����<� >�����<2m�\���3���ٓ�Σ��GgV�5��� )�:�n�a��oV�g�,<��d�g���{�ëW�w�;�o�K�z n�? �>��
d&�7���/�?��;�%ҷ^����LZ}�M��g�
��Oo��7�/��>� |*2��Q�4X��@n��v���oWP�c�.S�� K|����RU�2Y�N� �T�\�T� }����lB//j����Π���/�W���+�����4�Ʊ-y dg@te�1o��n|X��F~�a�d-�a3�c���m�V� K��Q�z�-y��wW�K{�K{��՜�0��Y_ާCJ[��(G�M3..90�6�S%�>Ӥg��i�Fm,�� 5U�� �G��P�BBI�$b��}03��2���� p�Z
����`�nB��fM��fyD þe��&:�� ���j ��
Ƶ��c�r��n_S�ut-����ѵ7}��F���\��Y�ކX����� ��e4��
"K%�O���x
S�oC�H��˩QR!����7��^/�z!���fg|X Cߒ0�2���
���9g#�� �VQfT�qR%0�1R�h�_S�%Nh-�v[���KY�KW�ll:��X�PK 4�h\{�U�� � diskcleaner/platforms/macos.py�XQoG~��X ��� �O��
���@��V��"k}�go}�=��
���A�����$ h%�V%
�_�ቿЙ������jS+R��f��vfw�,�*u��R_P!s�� �T{Bv�� �E@}��RiU�>w�"9�f�PH*��>SU�P���i�5P�8>�A/$�p(�T���K ��U��=y�"��2wt���J�J%ǧJ� z5f�T"�?�PB|�L�L��L44�Hir�L��kF\��
�G#!X���S&�E��Z+�w��H���S��xcD2J>$�Q����Ъ��B��T����T枯�����*� =Ť!H<�L��9��P������5�`Yj!��� 2�r
VY��̛�! ܌鄗d�'ŕ�D�AJ ��c�8��0\Y���&��v
���e� �5�d��(���~��Ge�}�71Y쳦B�� �'��i��� #�]�8��[�G��>3�Z�Q��K���%.��:����0�MJ�/R���ue��� \aȱ�CNU&�d ��BM�+��������J� L�p��;<DR����!����c�rp �Κz�f�&�"�̱�Y2#I��yi��=���E�m+ ��ӃE h��I �[���h~A��B�h �,}�]�$1?+�e��!�6M�Y��y���l�Bx0��Y\���$vG�z�ܻ��4pX��@���]`VS�0)��IW�4)�D�Z-��j<ï���d��r���v�5��do��h����ϹF�ء `W쨙��^Α<D�n�}"��� n߉��ݿ����i�%W �(�i���m�8��p��Յ3��g{?>;w&���q�P�&u:�P�և���7^
߄��/�Y�ө��� ���/�&�@�A��g �"
�ն��W�Qz��>\�����o�7�� m�o<~�sk���<.�sU�ۼ���{���� �T=�3��RMg��ړ�Ȟ,���
�����f�6N�ة�Y@V�����aw������-��)٥"��Il;�x�=FN��t���>�x4������ݭ��/_�~��_�h�a|�k`� ���Hg|ٛ#��T�g�8��u��5ڼ;K�kv�3������ }�@����~��
tx���Ɵ����b ���y'�+��i.
�S��>�!�ϙ3�`[{Yf��E���� ο��@ù �B��!�3��I�y�F���Z�do(�4��-~�̽ (�oXvOa�P�>�|�J��k�)�.>�NQ9sj{<� OIF� �JȀ r�h��y: �2�NC��aeD/a�f�U+��y��:+�Y�@�1 Ũ 6�Lg�]�7c��9~�{� ]1��i��VhR��ĝ� �n�\;Y�=�� �S�g PZ. �H ��0��4BL�Մ]J� �L��&��'?8~��J���v0c�4�p�Cni��k�h���68��x �p��D'�fV4�Sd�0_1���i�_^��Z�fO�io
�8S�iO'�L�f'`.� PK 4�h\o�Q�� � diskcleaner/platforms/windows.py�XOoG��S�� l�8E*j�4R�$4� Z�wg�i�;��qSq��(�RZZ������ �4�8��
}3��w�k{Aa)�z������{k�0
Գَ8!|bQ�Z�w�to"��Y�2�T�˅B��mj�T$i��c�Fu��@��?�l$�����|�2 +��\0�}�*U��(8�5�l�ԫ�h�B-9�����B�r��9�FQN|�R�� � � �\j�J�S!a�j�`�^����D�*�d��N��\�o��"� Dv�I!KRy���V�'�BoU}�(o�r�!���>�\5&�Iib��P1 �F�KF�bZg�����L�Z�Y������ǭlz���Zx�*GdSN,�8%�'� PI�]m,�TW����#��� e�+�gY$!�+���h�*'�V#����V���=��% ��?�}��5�� �Ih�i��T(�� �F)��� � ��X�@ԋq�:zM�V� �ˢ˥�q���9���^�� �3X0H���p��|v %H:�!L£����� o:q�����f��C����L���л����"�TlYT gt���Kt!5���O�U���T"n��g~'��M�4o�s��4�'��Wv���6. ���|��1Y n&Ve��h5k �n��s�#��s�����2N�{-r���A)w��,������g�
�����a&7Hmh!��Y���$���Vg������ �cj���_}��
GF���G�=��"&��P1y"���=���Q0�Ec��h��D �=����Nh�l�q��N�k7Վ� B: ��P�����9�x�g���ASf}�S_+�s����˗��� <����'�w� <�� �bK� �d�/�%b6�@�Pp�~�˳��LJ�?^�M)\N~5`mË�Y���~���Γ� �� @�/�`(��.~> �q�h5 �< �0x�Wp���{ ���/� >���}?�q����ί{G{^��1
I�y���`|�����)�c@���HD�st��w��?�-��)<lNτu�N����Û���W�]9z� �sxk�
n?
�nW ��A6/G�[_/����q�ͬ-��芖O�y�+.W�>ֵS!bK2?��ZB�د-M���`�Rs���}m���^��g��Χ� #gFX�3��-ӆR1��-R�9�&Ӫ�+�#���@��I2�)H�@چ��Am/I��w K�}x��c�1*$�K�q��I&�k�ڒ�� ��-��2�������s8!9E�]53�n��#24�孳`hMa0�����=�;Vs��N݃
�,�Zn�b,���~61�42�h�\y�-����R�p��]脖�kj�
��kp�rւ"�?Fœ�S�� ?�a*�����u���*:昊Ne�\'�O�Et3��t�%t ���Tʊ�a�g�$"� h2�%�PK 4�h\M�{� ! diskcleaner/platforms/__init__.py��A
�0E�9�0k�
����
H�'IIR��7RS� qv����Q�����o�`
;6��`
�@�婰v�K�C��n�R��>V��� �CL���>��<���u s<�cM �8-�e����&�aW�𫁛�f6�ZQ�M� PK 4�h\ڍ�; 8 references/temp_locations.md�W_o�6ϧ �M�Z���9v�p#v�
0Se�H���x��; )Y��$�^l��������
j ����b/xF欬��zKn�`d�2j����d���*�K&-��Z�����lŤ�kF�t␅�TՖ�V`��F ��V$�`ډTӰ'��l
��������\m�[ �r͵���՜����Y�ί獵 2 ���ީ�
��Q��9G��~4� ���p><M�E �3� ���W@^�*ܱ�]&A�VD� Q��jV0�� ðsZ�$���xf���٘�yZ;�d�6R(�;AH +�f$�ي�dL��t��{�1K�����K����#M
h _�yh��V�~d ����;�r�}gv�v��I˴d�\�TBi���MA_�BJo��+
`^yһ���Uֿ<x?h��;�����Ah;N�
�iVJ۬���qv�0}���6�>M D� �4Q��Б�V���*��X�=���? �c�:pGj $�Rt{cg���VZ����h�J-h�� F j1f� ���?T�H+�:_ �����M��^.�<���B�$�%!�Mr���`M��'�����K���� ڽ[<Z�?͈��e����d@O\N;�dU ��A�\���!�I��R-!ug�[MsqD�%ҽ,T莮�<ĕ_�*e8f��8��6�s�e(O )R��UR�k�'�:��)iv?�u]��[�<�4_C�m�S��*tMuo�ڛ�B� ��G0=0̘�-��&<u����N���������[b���=��<" Q�^�;�����X������_ �[3�k8)�?�;Zs�'C���{MD ��� /]3Z�w./ � �;��c����W���PZ�#��3l�M-�jAȂ1[3�* ��J �f5�� >8�n�+�j��<���r��ʞ�ޗ��r ��v��bl^G~?#W4{��w��N�p��Vf��A!d�e��v��� �<LL9�4K��8�u���l� x,� 2k��a?�[s?�Z�&8F�)\�.T= � ��%g0~q*�Ǵ��>��� �:[�4�u3�E��Krv�r�A���z�c�J*���{�W�K4�V;�i�s�5�_�����9�c|K�wɜ��< �A�f�_��Ȯ�2�� ��y��1Y1:��?���{f�}�\�\6^b�2��'v���Ƀ^���
^�]Xh�"�C��[Ž��Jٞ)pB���������>�}�A�cvKnkh$R>�w�'�Hֹ"Dw̠Ss����S�At�q
�
��/PO������o�h�pa�!�^���$�|:L� �����Ҟ�R��`-'c���n\��ϦN��@�5h�<����{�i�Y��uQ�B�m���8�`�X�U�����D�@�����
%��0�@���Ml�'��%W�yC��$O�^�sํSL'���)�� ���)�� ����5z��Ɇ�h�,�+���0`5�u�&0�{ג�[e�
��콈�v�Iua� ��y��T��ն&0�Ұ�'�S�����ŢS�UQ�lg�E4��5nt�3
Dz`�<j2Go����"'y�u� �{ʛ��� PK ��h\�- �8 TW scripts/analyze_disk.py�<io Gv��W�[4#��Ck#d ��(���r��&͙������ ȇ,ɗ�]˲-��X�+�ג��.K����B�{U�]�ǐ� ,��=]�^�z��]u�{f�#�7½%�]�}�`ɲ��!'<�f�v�� �vW��f�� ��]�~�a-�R%+�N�"�wK$5z���5Z�iq/r���v ێ �X�rތ� �J�)o����Ŗ�h�u!�a���@T�� �:��FN�yÎ � �D|��t� b������P�)���p5,� �cG pq& �oQڵ�EיW���SD�]�[P�9�h� uB��D���Ri [�����76>�������W�� n��������?�-1��r��A)
Vk%�>��Ӄ�{_��}��[�|�q������y��浛����/����V��;�<�`���� Kl�i�u� �Q`w Y� �n� >�:Q_n4���F�ڵ�*0�w�x�B N�t9��0Ϗ��!Ǫ�A%!�_��� *��a+%�L K��X��m�B�G'��5$�� ��sQT��n>�����{g��� ���v�� � �f�w��3�LNN�� �c'�rtj�Q܂d���/���ĿN 9:���)�2���� ��� �h���g�k���ŕ���:Ӵ=�G�H�I0������_i�nĦ��.�Cƕ,��{k��u�]��E������[����?lݺ�y�Ǎ��������[(�?�W��ŭ?����E� x,�M?��xΫ��f�P�)��f_��詠���8^Tn[��ځS|� �pNp!�q?7/^��Zcg��5D:��$�Z<�<IN !"���j�);l��>�����/7��JV11�п��o�/��� ���w��~# =.�b��tm=4#�~��x�5��D�F9� �m%$�nA"iOJ"���j��"( M
�E�����@��r8�: {�4^����8�M�k�T�� ZI�A���[c��
�m��F
,��#"�����)�Z��S�N���W����<���9`�o��9��x����v�j��2]������w� m?�t��7��QTξ����y�Oon^�Ԥ% �#y����� �I���F�ɢ�#%�_U�3���h)���p!�
~E/o�(^��5Ő��!x'� � ���X8Bq���V�Y�:^�_��M|0��Ǭ��k�%ȹk� ��edzj8& �yb&Lj� ��>�x����1�~�s����麜��~4�5�����8Uƪ��:� ������o��b����/m�����Q���������[x{��U��l^���f)�B�9
���;�W������OR�RP�_�^4�����7o� ���?w7�ziN� ����s9 \��C�Ze�3�k@^Ū$H� k�=�8��G~d���y��%&p�B�{d� ���e� ��
�������*V 崂�LV]ǭ���@�����П��.#�X���e�Jj*�A�s[�H��� ƈg���}��)��l���+�{%SQY���dQ�S����w@��o_�۸~����c���w��\�4s � �{� ���� l.� ���Z Zd���v!�8��N��\�vLC"��� F'�FT��B�:�3�� �i t�0��> h� >D���i '�����o��pR�a��E�]ϓ��F_�v �M��
� lԤ����4B�� ֈ4��NFu�=g �
o��C�<��nl=����9]��`3D�� ����j� ;�������è�|��uvƀ��dM�Ö�ʭ���X���Tj�5Q a���� 8p�2��+��
X�����{�R�`����H��b��cȰi��i(��q�����7��do>�=�byvșcz��U�Ԃ��������_0?׆���|(a�7���]a6.~�q�X���� L ���4���!A�XH}��tˈSF�sk�#{~4�^4�~fy��W~���H�UG�kL��#���� "�c�x
ۿ��J�������� �u��������!���nެYY�-���0Ұ�t��mv�� �]"@�7�� �qᓭ��b B����s_|�y�}]�uNI�UX⿒�Qh�������S�����&����D� ����
��:yFPa� j.آ�!SP�aF[��UA�ȵh�K�L9"%
PQ��h��� �]�y:4`z¨e@�& X����d;�9��
� տ��x�����v�)�nF�] ���n̯F ��f�����+�fI�CuY¥��VO������* <�)2JxO��Z��g�}��h��6�C��f^!�b~5����� Fդ����\��0W�l���F7��SGʑ@8Lu3�,e��hCSRVPД��;�g$C�!��P�4��N��X�!jr�6�j��D_�s���h�#f�h�\�ڡG�i���9�עdE ��E�q:H� �fQC��ҘڋWLV)[���*a����"���V�q|%��v]�d
3+/�u����˫�de�L#=&��D�PO��=ci����
I��~�
�P�Z/�ܯFjڔf�]Y ^q�w`V��s�� l�^�q���/9-N� -�`فj ��;/t� *��3k�T�R_�i���Q#˖Ɯ�����}@�m4E��9�4O�*8�1RY�aI=~\Y�_�ދ�vs�7��"֪Sv~GL ~��������I1�cf��/��x&��Z�ZM;����&}��2th@��&05j��ҙ��J�f��[�~SP�xm�� ŨR ���=�}������R �R Q�S�� ��^�Ƒ\g�B��4m��si�x 6Ňلd�����K!J��H� V��#Q��(Y����?;���
-#l��؋;�G� ���`����̎5�Q��dS�1`=��
X��K�t؟��@�?igg��D�?��S8u��˱���D� ���˗� ��]�S��aa�'�Pu�0 ����*���\n<�ռ�:�;L`r �� �-b�+Qw: �r��c38c9(k� �^ז�X�� Fe��|V��,�tN�!�^Ь���z��gwSU=j���7h9i�P�a��(�s��g���S�r��U=��z ��{���CL&�wȸ�c��' �(�Y�5|>��N�0(�.W���$�)���>��cN8"
_#�v�{ky�Ȏ����g �|�,^�w[�ãE��������W� 3ZMt�{!�C���(n�� ��Bs��^C�M�T-��M��ә�OAE��y��Q|�
b R�i���3���( �Ubu˧�jݵ;�-�����l�H d � !�㞏L�ϓ��Ѩ}��.\ܿ���@0L���ٚ�d��P ^~JA�g>Cm�C�@�e����.LFd2��l��.���UӴ�7�\����_)柤5)��!/��=W����ar� S "r0�1o�����M5�~�2� 2�9݀�������]� (Jr�D��V�2Ei��֣q �u�f�j<���\���v�ʯ�j�u��E~�@'���"�i�X +���v�����[4�9
��n��SW�"�#���x'��S�I��E�J@mn؍t�]�r�'��LD �2��3���%UC�CREڷ� �,���x�<6�p>�J\�+��t�������
����&N�9)�n�(���y�n�J�e���ޣ%l� hǙw\'Z5ܖ��x���S2����ϗ�VEmL%ʓ�#Ӹ4�B������ӵ[E����{��i��{�E�H���t�@�D&�)~/�(��&{$a�P�y�Ig�����vjѡe���ϭ0$jF��E�� ��H�_jK�� w���v��u
H�k M�D��E|���* �'�D��bAo�� ��P���i����K�M CLv8� �~�<�)y�7{A�,q0�IFWKc��ߝ;60W)� �4B�Y����̻���U�M݆�'�xh� �s� 7����a�7���d��l� �J6�^ڊC�d��r�}A�u0�乶*t�l��:6
FҲr��L݁Uɐ��;^9
w����щ��C�&$f�2��I��Y�*�NCxˣ��q�z���#'����"Z��8:�ǖ<?��a�F" 7K�5����r���=� yP��}�3�"92� �� � �m<)�Kv0��ְ�4AZJ���{�U2�!��� )&/�yx�E\�Y_��u]� �����{� ��,G�s~��ڌT�>��&�zf3h��Jxz",�r*�܀ۮ8�?� �\�������ONB������ot���U�@h���+��.�T�V� ��u�o*l� �JW��h][����B�{'�?M�"��%��IT�qij�j��mC��9s�
�qq��� ��K��<^����2ggf33'��(��i����y�],T*X����M ��+L&�'T�@�� ^?E���A��?Q@��&�!v!���Zm����㰦�9�)�7�d�T5)d
�"n[Ү`��;��� ��mI�"�$������ .���:N혌�<�̣��jɦkU1�;����:�`r�P�� �o�=�d�a�X%�b֢d� Zn�ܷ���@�R��cF�5`�O��K� c0�U�`e�[j(���
f��q�6^�,�,��;����U��Б��������8>q��f�̰�Sx� x�gd��ǃ�n��$H�#�U�����Ԯ8����A�8K@ЯL� U�ݏ��f+5ˤ "^��kLUT;��2{��Lm�Y[���r+����f�݅¿�d�n
�� �*1�r!���T/�iR�b%@S������fK$����W'N ?r���`Q3p"�u\L��\�I#y����~w���H��t'�B�:������ ��PRM
*�wh��L��tn6�۴@�����ܶ�`����F�����=Y�M�c&L�`��h����,�I�Ý �嵄G�47�}S$�� � �9�)��X����e�|��Y ��#`Y����V[��K��Y�2��v���&/ 9:�0�0]��eC{wl���w��v �E h�� (���tlR%�� �k�t����>W'�� ^q3M%�7���� ���s�ݶ$���k2/A��ݨ�
���%�����êjͻ��/��M��i+rq����X��ƽV�~F/$@m#�� ���^� }q���n( Q ��vWK�83C�
��1~G|lx�`�C�p�_��Zf#��� #���ۋ=���K{k�2Oƍ����i��ņ�} Q�]���p-��E'��E]�����̉���=R�wD�wa� _�ӰJd)1��w�hҊ�fÖbZ�0�2܅�A��ִ �e��]b ��ؠ��̃���S�������j�x�3���61Sl��1�H����6o�&���P�|D �W�N�ü������>����;Kt)�a+;�W�7������arA��H�=������vS(���7���
��o�G�Y�o�Vc�d9�S�w�h�/�[ex
��<���U�3oT�J���|��� �8���E���A�����3�-1kaj��&i2À�`��OΏ��Г$*A��������iTgb̋��� 8��i����%�B�ِnY"B����,}�&а bX3
��V�֍K�������G�v߉x-���n�ʹ�J ��4�s������Z�أ�oa��� ^R.-��٥y���~|���@ռ�'�f��w��v���� ����u�a�hi�^�X �� ��D�$�ߺ�~�#qc ^ţn�»��]���k=��ٺ���՛�����-U��M��IG�����wC4�w���yJ��A`�A�'V4
.��k%�����O\-` �GV�qx^ ��0E��C � � �������n}��~�b�^`P�3��@P��V�}�������{�����ڽ �U ����//��۟�ќ7:��v��� ֜<0�̸� �{j݀��q�2� �.�[�:t���?o>�A �[?m|p�MF���$�ٱ}�ÍOno=� � ��KD7�������-�Aj&� ��BVJ�N1'f� �̌7��9I�T+�N%b7B�{e���~h�ڦ����5�2���/ϱ��!X���3ZS�� ����F�V
��
�v(¿�� PK b�h\��� �@ scripts/analyze_progressive.py�;ksG��]���+�DdY������� ��
'�{˨����L,�hgƀ�r�������7�,�
��x���F�O��=����yX�ֽ_�|�5=�O�>}�����o�glkxR7�5�$j�:'Lc��/�J���^�v��v�W�;۾}�]:��x�.�@C�eNY�m�'5�_���^C���Y��������܍W��G�ks���|�}�[ǻ�[�}#9�}ҝ_�..�~|��~�^��n{)��=4�~t������� j�xӾ����������'������������GN(�jo}ߺ{��ﷀ{e�{ �6_>m]{�Z{о�]���@�"S����
�r�jM5T�ּ��m��^L��i��� � ��YG���+b��;��P�5}�=
��3�Ѝ)�a�^v��n��#
G7�����|��}�q��f����Uwc������u��.<��s��B ��.[z�Q*���d���T���(� �Q3� ��Y;��3��^E�c���d��
<� ���&�YSN7l�r����9�)Ơd���^�)��� ���3�5g��Џ ��eu
��UMiX:�����M��8��.��>��u鑻��]y����,��ЇOP�"��b��iK�ӌniJݬ��4���Z�5����G�}���o߁��,:|d�W��6s�N
x`O�k�jhG��x��X� /;�5;^V
�
��0�)�I��3~�}�Qէ� ���i0���0
-'m���N����� �H���[����j �t��vU���8�ͥ5�Ç���+�T���>\�0"`SGk���a���j��mw�.(w�b��{y�u��;kT+0��1U�*R"LJ��j�,r@Ih�B��yF]F� ����L��)��Qgj�K:��w���QS��iձ��
�^%(�
�l�>a�2 4/}��G!zJ^k� 8�(3
��8T>��ɸ[
���� ��\z�\�n��ߧ���b�}�-�1�ÚG�*Q��Q1O�) ~,ش��R�
Ǐ $�!�� [�<��j�z�.(}!3-�j�T ��H.O&�UqpF��h����ta��[���}{�}}�}����,�?�m�D����>�=�o��n`������2���n;nL�*E�/�ˡ�a�s@e&�i"ơl�NPd �Qk���Y�D�bUoK �xA '�����&�?ܬ���٠�͂�۹�,N&��Y�r��%���V�Sjm:M���3id��� ��
R���"�
?���N�s���'ETӌ4�� C
\g�d&�(��r�um��� �+��
8K�;���[#�|����a
��ҁE�=�1S�,��t���+E�%z�B���
�G
�j| `��-���#I�
��K ��� �3��|���lU����2�,:�Yu �i����`i�uH�{� �H� 7�Wn����ڰ� �P @��b�@T�;� P� � ���!K�4��5���H��
�j4G>H��5�E}r��Qw���~�]x�y�{s! �L8äk6�Ĵ�@��I���d�.4�8�(���P� �g� Sl?��
'���X(��I � ���x�G�ݵk,�E��Xe@o�M�y��%Ȣ|h� X�8O<!neш�c.(,D#σ+�U6Sz ���T&�ݕ��/=�*����Bv��K�K�o��3�(p����U��n>��T0&e��0.J�0�����{3$raQ���;.�N��˭��R�����r�� b��"6ɇ�2 �F` p;��ׂ�`�e��5|O^�Ɵ9eu�4�nv����T��'%~H0 � V�( �ՠח����gȤA5Ө!�h���ZS�O'̃��GTX@&�7W!l
C{�c�D�R`P�<)�0�֍
w�!����pgדN��(��a
El�M!��&�;�ɍ��#:�{a�����ˋ��8~ﶗ��m��ͷ��j��,�L�h�4��z��KF��oگ�e���J���/��yx��E��͗�t�B�~���ۚ1�X VR�<���]�p/<N�Ztְ7}���Sk�mg��AH.�G� ���>��D;n�z8� D�z�([�T����a�3Q�2��_l"iؼ��c ��"�b���sQ1B�.��Y�~�@1����e�|BS4C��i�_��B�?���W�ZK8�A$OD��߶Wυ]���?$Ư�6�ܳB�/�� �uR�Zs4GD���2
�CUL��|��
� "B�nTM�I�kA�<eJ3p(bZ�@02 ĺ�A������1'_ę Q�"�N���"��'Ķ� �� r����A�>� �� k��Vm6"��[U�ɏdÕ����<�f�H��a$�烽����1K�F���A#ypDZ����p�)� ��K9���hp���.��77$x )C�k��!���K�K��Ø�;cM�4�
��G�\X���B��s���ĭ^�ʑ�=�K~@��p�z�i EM���a�
0W;�K��7ܣB;�����&�F�tiJGv{�8���(e�V���L-|'�����2Q͗��q鲻��zN�jӱ�G ߫�i9�im�XS��.�����mi'5�֊l�;O�Q&S\��&
�� 9 �G�!��[� �p��m�(��a�%cDl
��>Ol��@|�<��(͒
�g�24q KSmӐ��Vb6����
�\D��smv�T��AlF����^ 7�a�M�m��OO��� 갆c���rV��?�@��,=jc�6�.��-�JT �ױ�Έ�qt(��� H`� 9[�4�ا��*��b/i?� �� �� �dQ�� G�Brz��ũw�֕�hr4�IfÑ�K� J%х�F/�/;�|I(lz�7��cO8z � д� ���
�2��Q����H���b�hz��q�'GFH����B�'�]?B�(<��cZ�SO�c+p4��'��/I}���cR� �
~n��!L;�-ƪ���Q�4a�=8+�v�y�����>�{z��;?��=�� �D�]�G¾� Lz6~4�6A���AY�G};Hd�YdX~N����;OL��K]6$��
�5��9"z��i\��;֪���E{�^Ӎi^G�^g]a/�\��j"
x��$��[���MT�~$�O)�C���c|���� G7f��/6*�����?݀� �ѫwg�Y
���D&�f���i�SJ|�ч`-�H?������=���E.%��6� rW~f�"$� gztG��$�3�����1�� ��K��ԝ�V&����ɻr��'��R/���50g����[�d��@�,1�I&���be�� � ^��4_A< f��#�3�|���x��!�(kb�BO2I0���E�2kL�=�`�6���������}D�'Z��5��/�_ 47�E�����0!t �"�@��/�=W�'ɇ���H�ٌ��d3�z�q��� \˜fV >Et1e��m|Գ|�u��� �l��C�@���L��'(UL���]>VM�?8�9����C�=~p ;�˔qͮl�i��P�>ϼ��1�l�c��s"�vm#�"(M�֛�C@t� r�C����)0�)�4$�L�;i�9��~IJK<!Y��H6�K��� ��(��Q'L�8�H� 5�< �_ӆy��H�<���hhX=1��#2]���X �"e;ށ-t
-+a�K�8��RPh�v5u�21�T�`i��)< ��F4g)@� ��OS�p��>�C�+���W"1��Qe`/ի;3������% ��j O��y�ܬFq������ @����מҊ�L�s� "��
�&�v� �9B��� 2@�nNo�} ���3��S,-}�z�W�@�kS7Ҥ_�ދ�f��B#_�Е&�L^0����^kj_|9J�e�^���s��_����]]�n|�&��:� ru��{L=�� ῴZ�3*t�z͜*[��
�|G�7(t�{į�����
({X��C��,טECC�$�2f@����F�W^�f(�x��X��@Qy`8/@���i��.S����<@ݽ����~� ����������f�#���� ?j�_���S��:{�L&(�9�RQT&��E�ʢ�P�� ��/�d{�a��Z�r
����O]sk!Z�v��- `rfZ��{��2ERS s��D���$EcZ��%��e�WB���!���� ���'�Y���#_t�|�.n��0��`��x//�%=��l�?f��?<�p)�I0�0}�,�;��pQ�|s�����!�T���a�٫6��悗���'E|I�,&�1��& �\e�ްӁ��e�
��8� ��0����8 G=h������i�*=�_���8g'Dݟ��u�<{<������d�� ���#�896ߊ���{��;�g�jg�5��9����Y_O�o ���O\9ET�Q����7/6__wp�1 50���.��>k��������˔�w���ۿ�.=輽��a{�]���>P��Uz%SN���'���s �_�IȎ���==�p�g�p��3��0�F��Ű*�&6!�)Yp��P��]�uv�}�"��G0��
n���}:���`E!75���¯j���b�vZw��9���\�*��UBqu � X� PK ��h\of� �$ scripts/check_skill.py�Z�o�V�=R���E��v� Q[)'� m=�J���"��
�x��%�H�K� �RB
I!�@� Y���/t�������=��^�n��"D�~3�f��|f�x�}�]���3�ލ�s�8f�5��ΎT*��qT�F�
+:6�{}�viǹ9U+_w�:� 9S�:;:;� k��Yg����}�������]*;�ݧ��
`��,�۾�~���W�ܫ� W��T�^�+���� ��� j�h�62��Ok,���)v�0 � y�(��b���3���G"��c r��8On87ѷ��3F-��>q��t�U��.tv�p ��j�YC�
����?�J� ��$4j>PF
m\Ӓf�bSL��>��ۦ�L�c�c�'O
U<k��]��$"FӤl�X�9$�����ɒ],�G�O>>p�`:&8��*�bۦ�I��3Jv gJ�<6�tLN�h\
E�> ��y���oM�X{�<�4���5r�>�'��|�a���aZ}����Y O4U�2e ��f 7�ok,�mmlH�����"|>��6��~�� Ӿ�XV��k�ڪ�rǹ������y�-�L$�) �"�a����E�mr��N�rf�9Ԯ_t \���Ľ�-�S�Dž>��OL���4�Ɍ=��
jd��숨+�C�S�Ջ���A9l+�fykpP�T��}�?�n�rZ��&�O J��R�, O��3N&�8�#������Dh��z �U�=2�T� 6-�c^iO]4����5w�_�ڌ 4'��>ɪ�7"�2u�� H� �9!��U=�9k �9���{�O?B ���Zmf P�Yn�Æ��=|��҇Ğ �4 �(�4�ۍT���F�B�4�Gv���72��H�;7�Y<�D�f�? �Q�D�?+ڙ+CM#�jk�����\�n�?��mh�n���I;'k�/ϧS��Ll�L�7�!�X�i $�� ������ �h9�si(P�0 �H��·,�G��q*�&�bb�, � ��]�FY#�����@�l :�ū���^�_�����Ǿ B-XzC7�C|��>x]�����fn˚jіs*I.�J���W5,�i����` ��9컉�`I���QsI�EH,��e[b�Y,����]�՝~�ً�C���9�{,�m��3�H� d�c^������:u-]�c��,��t���:u��W_I� �f���/ܥY`vW ����z��VtE�'Z#Rq��V ^��[�B��4_�|��V2o�t�<��1U��Ғ�`@�4��~�~���%��'����}�)o�b c$��e�*˾�6��Km�������1 �g1���=g�7n+�����w�7wn��q-�<� �&#p�a���t M7���!HT=�.��%�B�Iv��� �� ����LA�$' )��`�Ȅ�I�1ɴ�W�7�_��g �NJk�/Dr��]��m��4�}Zyۙz� bǿ@���`W��3u��"ot=z�x0c��@ `N{�%
�h�C�cI�-l��L\@����K ��1���a���EI��E$}tK%$�_�i�}�S��4�H��i�
�L
"��� 4n���Pm�Mug�:[v~�ĪJ)��<{C]-�-���";�R#D�P��E2�ӵ��켹\��!��i��hv��ԈT:^�(Co;��g+��m� ��z�ȕ��Z�*[��M��=�j�� L,�X�vL B#��g���р��-���ȉ�݃��#M�d��9�� �L�v�hH�����p5/�iT� ��KܕK� � �x���r�
�!,���s� �*/�^�ʻ�)[�2 ���H�6\U������� &Ċ9�9<"'���Q�D��m���������Ҩ��XL�زS��W��?�w���%�%
c�L� ��b ��{�f����-�^|�R�����8�DŽ�b��{��I�>�iuE�-g$���JT���ޝ���L���S�� %����P����jh�Xsέ4��{CS�4�9�5�?~�����6t� [�%-~� r�8Lф�l�8O���v�ǯAM�U����ɯ����Z�z��Y3X+?u��~�=ݪ�x(d�.rVf�`
�c�D졪���JNLG�="��<�
�JS�m�G��P��wk�WS�5�Ԙn+��^��O(�6�/�X+��T�bz4��҂���=c�- eAQ#�F���� յQ������N GG����D���o}�S^� �;/@a�3r��m������)�ƨ�� L��(���k�k���w��z���� �*i\��2�P˙�\_}M��h�~)A8��Jd�����A]��6=6
���qK8N~��i6k�1��į�����(��H5eeUƫ ��~M�̇&� �τE�G 3y��ɀ�*ă ���At? ��~�7lE6
`�ф2�79 6�6�� fdCڋ7��wt�5���T�
�,�]����Io�ۓor 5"���ZOOB��C�� AJ:s���#�v���[]X�c�b�-� ke&�t���3�Cu���A]L� T���~g��� Uמ<t�<g����ѭ��]q����=R<QT �����
�>8��I�҅�c�z]�wCb�{o F=�U]]�쮄.}� �'<$��� � ���o����
n��,��.]���9�ۅ� ����=��C�V�# �>lό�&m�l��-�oZ�qL���6[ROH p�$��m і�Ɖ�����%Ěo�� �|��������{s��$6?B�~y���g�_��3�T�:ל�GB�������6���O�[8����|�h�`J�ֵ����-��Y��6�) x�٨ll�o?�: ��!�A�<�u�לɲ��
Y&��,���`�{� �[�b�| W'A�� .��4ୈ܀��C�� ����%%��&K���59cX� B�9�_�O� ��
Y:��b��.����I�jC�a#���WϷ�H#�v�W���rz�B�QG�6����la�\�@c����"��=TGB*1��eX�ϩ���H�*� U>���o��`G�S4�ΎY��f����� PK m�h\)�&� a scripts/clean_disk.py�<ko#�u��+nFD�%;����(��hW��k��
�!y)�w8�� %� Em��� Z#h M�p����A�$k��X��O� =��w(J��.?H�}�{�y��3K�Y�f�j?�Wi|L&��(��[�<��
��d#�ALS�B6�$�V&Q���tLޜ�w�(�(�!�^0�ь�t� ӌ�t<I� ��QY� �����C��C��G ZA�j���(�tHN���L��0�YF�A�X��i�ÔiF����n�a[ q����%���d�D[�Ύ�y�_��6J�19��1%�C�n�;�Q ��� ?�¾ � ?yG>���l�I�� ��h^�-���������?����_�������>���_� �����%A�t֮�,������ߞ������;�x��|��w ��������������矞�����՟>���? h��0��~��Y�,��$��aJ: ��#�}�њ)���<��i��&�#��ż����1ҭ���X2ࢥ������,�m��`F�z�jͧ�w�P�i�����5��d8e�����/ ~�Ƀ����g�������=''3�ucwg������5ɍ����� УzA�ݽ��{0�_m}k{���&�2��$���H�B�������ּ|��(�U�n&1����Nr����IL��P)4���w��W��}��ߜ��=��G (���ѧ >��� ��#N���w����\~��矼�������� ��D�:�B�A�Җ�U���\Ļ�N�1I�8����׃4E: ���?y��C���Ha����@)�� =�̚tP�|HӔ�N�j�ᷙ�Iڞ��+� ��`���>��m�&��������{?>��7���~����h;��B�6��/�ea�9�C:"� �a����F�&�3?��m� �& %'�����4 ��|���nut�am�`���5�%'4-��d2�����������I0�лfvR�k��q�7�I��?6 �'ӼfA����|q�/���i ^Bbz <�s��D�4�� ���o�i���k�����4�@�^M��!��(�x-zJ�f�mEV�� � [m� ����6�^��8r�s4��h &���]�mH�V[:[m�,���,�ڎ���B۩�xV+���da����.�>���v��s��R���d�i4�ЧB ���I
>��\�/<�u=��$���I浍M(�����ы�}��!�Ѿs�u�Y=�Y�`L^A�_x ����K��w�<p ;0ZƯ%���g�m�
��4'7wn�l���$i��X��{��� �I6��m�Z�%^��p�a�S2
NX QÁn� �MN�rJ%px�D.=#a��~ 8��r@'���Y�x���m��{ek{�C�.�Z��j�F��`8�c�
8�|��!a� !{R��c���`u;�cRٿ>�DHd���� F��ة�/swΗ�n/� 8|&G�X�8�B�Xx���U ��5��� �p(�u�o���3�:q�vOO���0y'D`��^�^e/�b5:����XGa�ԩ�:���?ϴ ���q1M;�����1�����p<Y4ȢJv���i ^Gtp-O���0#w�����Q���PC�D�P�"4IR� #T��e� #�� ���8�A�g���+H
{�F13p���=�;=x4�kA4��l�=Z�Haz��1�x�MG��T����xY X�V�~H�Sn2��p�CX���0 P� 1� H#H2>M H�}`�\?��w�t��(��7#�q��)U�0�`"� Hc9)��W�E�����9G�q@�G�l ��] ]��f ��0���؆_��.�,f�L ��-����]ͱ!���5��S�H� �@g���� Q_�g��b> ��Yȅù��J6��p
E�.� �����.�@v<�@zm��&�Q�?�6��`Gg I�?5��`��I4d�gW�G4�д9Љ�0&�7
���{�6o�z��װ�k�ܡL��L¸^����������]��. �P�d X�����-f`�u �ږB�\?g8Ř�\I2ƿ�4+6��v|# �I��rlQQ �nҜ��Y�/��U�q�ד�0*��w�(砪�6�1�Х�`U�>� v�ee�"z�VE�~�?JN��.��� E��X� �����Ӧp�r#w��dk�z"mo�R̄�� .�uuM}�p�m=u��[D�uگ� x������E����#N��G����=8Z�{[�m"�m����[ �3]8�Jޑ���K��E ��o�M-oo� �hG���7^��nv��K$� 7#��߈8��.Ԝ*=���d~|Cx ����.<�K[���)��>Ұ?ET��+��$L��cvZ�Z"�`��c��m�U: '"�q9W\�M���P1f^�^m�/i�h\�V��p �� v"Y� ێ ��b��GF,��p@ ��s1�V�H��\ �M'X�[���������5�BE�V�/��Ub�����aK�� ��� �ӐV���]YD& �-sh�I��x�S�.�~m��x�sA) ,qa�����j�v�a܁� ���9�N�y/y�X�WY���f]���0 WM�¶!����,k�r,�#�����oQܗ�X�6��4�`����d����Ǩ���P�Y��Z��] �XQ� 0'�S, ���y��P� �zzXb�EW� FJc�E��8��|%��ć`v"�?a4�a 6 ���dc�/ &��e�9��GI_�B���G�*�>�Ą �4�Ą�-�Lh�d��� ��cHo��|��dNf�>��Ab{�p~
�ؗ��6 �X�����q_4�
9-�!��];m��dr�4
g��X� L�d4��Q��ZqrR�-n�Ցם��h�ke���F� �̦�p4d��4�e[1�4vl`�ٞ���!�A]�A�|VΗu��n�h\g+4��dͶ��
�6L���dNzx�yR"�<i������y�ɱ��w"�pA4�lag��?鸂��V���i�#oep� "��&ޮ� ^��lj/�~H�]�D7;�g̮<j�7��K�� �� y k!>�q��� �˺�T/��v{h��W���K�x���3�����ڋ�#��7w��ˋ���7�h0��� 8� ���*�]~��A]�p����%���7V�n �K��<�!/\8�d�٬�I�6�]@��*V����ۿ�t�.L��$<�������Kq�0����Ad�1���
7{��퐳B:DjBY�z�/p Rn7 Z�JyQ�D%���S'���H����D%����8�������4F�SUT�Z �� Wΐ[�� ^h ԕ���t fXl51mh�t� �[�����
7���G9|��C ��eR{Z-
�As���˜�"4^m�/���`0 z���(H�\Ʈ~��.�A��<����
{^^��Zy��� �&S�#uh�����!��1�"��s� ;#1 ���尟Ψ*�26U��%J�-��o�@�ce[yM� ��T5�gJYΥ �]� t�����G�q��i�-.�b�WA �D�t�Y�&@���qI�dA9? '5˞bg�$# v'��Ͳ��#Z^ ���}�ye!�đ�
&����P+o� b��&<{����H����t^R9���C�'^JA�y
)��.�"
8�H��e�DͲ��ώ�(,�y=���'�% �[�V䘧"�1������ ��C�r���ʪ! �T���Lĭ%"-��k�8ϩ6ħ�Cbɪw?� K� ����i� }k���`�J�qn��� S��E.�]��B�6Ǔ|��� �++�� *���e�M��L�B� |uQS>���_���z�����!U\�[ߖ1t�]�`��檘]�4ѱJ ���&,[��OY��_Oʪϗ� ��hI��1+��ڕ*~9��م,��*i�2�E�� ^jƴm��@y��Oז��ܬ %~� A
��߬z5�Y"EP_*���%'z ���p��)k�4l�̛ܻu�dm�����)�
z .�4����)�p`����y�B��: 5s%=U�ȓ ��B��z�{����[�2�V��a�G�)��q�V��`q �n�Pӱ{��U��|�D��1���+��`#�t<�G ��@I+�k�M�x�h��&��=�p�a�l�ʪ
�@T� �,-K�pڢ�m��ag�S ���_�8���~�
l�.�!ܢb�Y���Ӥ� 'C��{ݽ7��� xF�_Z���oc{s��Ǒ�t��� y�x �<G^Zkh]#����!as�n^'{���R��K���{r�eu,, �l��� ��;������}Y~[> 7m�����,0���/7�2Yn��=Cu��{��Kł�(���v��-W��T�F��c;&d?< Y�IF(f� � �>�]A���ʲ��kjX��U\}�L� ��r�b2� 5��IX��3r��J��_1��"�
^�V>��5��� ��A $�уC�ߎ�7� E�|����2 �Z˸׳&�!�0T�Ҿ�a�]X G�N��w��Ȓ%��.s���3"�#�-W,�k�<
h����{o�=S� ��V��M�gTܶ�ee�ٌV�I�=۴����
�J!9�4��̚$du*��Pgx�4��
��BE= '´�P�E�DSJ�A>�Z^q�4�P� ���$Ӝ����+�ڙ<!`��f8e�[Y�~��c ��#�J��(H'� �������zz8ŷK���" R��**�xc����V��r��P�w�t���[ z�F�W��b6����u���<�SE�& �8��h7+ѳC
��_�&^蕭ʈ.�ۚ�
j��u�y��ɰ��S���Ø��p1b���H #;��H���~u����Y0ǁ�`���Mm�N[��&���af"X
�
�0
��'��u۫�H�v�#���u &�Z�H��I�Q�g5�Ƨ|�@�s!ȞBT�`� ��~1��9�O�u�[��9��x=q���I��Lϙ���m {_
S�M8D]� �M�"lN 船̌��6� ��8��/&����7�,�-U�rU %���i��
pE�u1�Z�9�!nZ�*�Mh'ė��i i�뮿�+-T�v��&��Q_��*nj-���z�1Ӎ�� :d�$ AB��/y�$
�����ݙ�P8;�۹9�W �I��D��T�9�&�䂌����DZ˕��N|Bb4���-δ�P���b�/a��N���rت�3��| %Xca���mSC�Ĭ���O�*߷��ߗW�ud�l^��!�)�>�غ�3��[�|�� ` ^���/�Q�VQ��� ��[�R���u��u�]_qZ�����_�� A�i�D�E*_�(?���� ֕'@Z�;����KR�� Xd�}R�"պH��
aJ4��X�|���Y����Y�%��+,T�N
�l�� � _�z@U>�����m4,�� �2l=�� �ڕaYy�Ţ�<M���! &�%�?;������������^xE���l��-(��Y܄Y�5�um*s���Bu�k\�Đ8,�(��p�W2p�� ��E�K21��]��a�_���Ҵ� �o�Fv�T�Ѵ��8�|.8�z��zxv�����
�2q�/�P�$� �� W �,O���喅k-k�� � �r�Z��x���J�4
��yQ���B�
2
s �SX� �#��u��s�+�#SJFB#
����Y�= e �C ��ik��f-�Wc�u�g��}L��x���� PK ��h\$I�m� 1 scripts/monitor_disk.py�ko ��������g�z�$���8K�ĩ�iZ9����]{�ٙ��?�Z
�R�� ( H�
(}�J��$� ?�O���s 3����F FJ�3���9�ǽw��\� ��p��w��(�X�,�v�g��j�I�Y�G�͎7F�x8�2w������u�DQP�8L�qC���F�7hH�����(�qcJ�R�z�q� ��8!�bQ�~GL�R�w毇n���f��?��a ��nB���.F�n��}5x ^�@�;�9���A� W|��jSj�N�9�%w_;��Σ���'=�Ҙ ���� G�|px�πt�ृ�_ |����;G�>p���?|qt�o�����7�����k�/����� �����o ~v_� ���ેG�����GG�����jI�۪x� �� �6�v�� Pǩ7Ǡ�0i���`��u�� Kb;ǫ�0J� ��
A��_�~��x�|��[�q`�0���ӏ��ܱ� �I:v� 8� G���S�ѧ_ ?��菷 ����O� ���o�|p�ޣ��?z�3����o ����/ ���7�_�N�80� ���:�c�"/
(k?�����j�t� ?
��mIY?���_��U��現�,t���� �����uq�N�_6Ag ��fm�خ�v�X�~�E��� ��/J����$ٵ��3êGjя̯C��"2X##� ��t8��tݤ�l)�@k~�\�;���M0��,��(MA�Ah8�<X��4�>9
_�{{:����.Q��"88�� �m��G�ӘB�]��{�� ������w�G�~X���b0�qQ�ztH LJ/�c3 dۍC��bc %�IXv����ѧ�5�!�f�@���(e�S�h"eɠ]�~2NC���qJk�����A #� I�D�c��0
�H��Ü"n�?�|�.]^���� �ё�ꧢ�vV�N���e�H���tԀ莨f �d?��$w�M-��t�yd�Ķn��µ���� �b�j��2�4�Mk�vy��%^� Ŀ4L�q��Nf��yl
�t��2M K���3���e��:I`���
���t
~7e�3W�Q�8�$�1��} (̯f ����8D�e�wR ��r,��dh� ��֭[V ���Gw@U������&F�Г��4�T�%7��`�P #w��-�h1��Őa��$� ֜�+ZXDt�I�~ �2�B��4Ƶ'�l`mI8YWX
�*Et ��U�'��Cd@c)hx�����tr�áx�䥊��vG� nNd�`�D�0x �� �;ݭP���8�s�(#0�9��k��
�R
�g�O6H� 5*V�X�U�*dX=
��~HQs@��Z� A�l ��]� �
@�S'O�ɅɄ j�`�hk�{'�L�g� W' P�%)8�"C��A��Į?�
�`��Q.ԳT�5Y�Q.5�H�}����)dNpb�T9��ͤ/K{���:�A����
>S�7�� �!� !BN
\,uʆ��6��sшZZ*�!�ǡmf&� � �T�{ �<Ea�U�NZK����8zn*��y�1�̒l
��Uz��;���I�$/Et�t��%'d�e�&Q����͡3���Jf�{ ԻY��2�U �4����r���|Szo�e:KP�,������(�� Zd�jՓw�� O �9p�
��=_-�D�P�[As�
.^h��`��,쎡���ܬ&����;ca�F%�(��#�J7�C[��Bx>�
��N�qin�T�U��2'�?N:� <��Ms��`=Ey�9ƜĘ!��������d���7��X�W�o����˸�KLt�1�O�����/�hf�b�A.T��B)u<)�ih\_W�Y�iJ�xj_'`�L�2���E���.��k���팢�
]�����6�74Y��h��Xm��"� r ��\)j L�w�
��~� |����ۓZ��iZ
.'�k�j�垻���I��6�\oj��k�{���d-�^'�\\�R{�G �Mp�= �:��1�Vm}6�hۮC a+�B��:�� �dfOs>L�zi��U�$��Z��X��y�)z���xu}'a�
)H �; ��x7�<g���F �<��C�KL� =��V�B��e�� � 軒V V�m�f�� r�Be�̬�E}�e!x�h4S�S"��I��-��:Y�(�ڜ#ξ`�,ed��Tk��K'��m�TzJM�ˑo��qL´��4�o�#��]�0Y���к�M��g~<�������}�\]�����9vOh:[�ӽ*<����� F�s�*_��Ôk�|k��=�6�)�j��ʊZpz����$�<��n+�E�U� a�RTf� X�kLZ,����3�"]�#�#�ߢ� }���Ck�\�,�,�.-.\1 U�����u:�� +ז�].ҫ��M���zd�9�8�gR?����9mxw ��s�]�7����c4�Ik��Er(��o�l�$�8~x?�Tf�p��?�
�&�O�Б�N�@ ���@������\���&�c��"{ҝ���g`2��U
^VA�3�I�Mw�? >˄$�1|� �ٽ�d#]g�ȟ�B֔Y�WND���7oW�@Ӌ,�.�) �0�z�l�EI9�Q�Fx���є:��R�V��"�ɠ��f&��^�o/���B����dd�R�ȂP& @�14f�(�y3-f����%�SuHOc:��>�2b��im�����BN���vɞB߇
��y� O'��/0����㋘Y���⳽�㙇v.Q��Ue�a�
��yQ��[�m�okcjT~ ����n6���#����ֱ� ���� � �����tɥ�jgq�s���5
�ki4���%�;�͛<��Ι:Ӽ�� �eHw������Q��ne�����m���d;�� Sw���= ( ��uOGK�͔v�ԏ���mn4�
w']�]�L~c~'����҆f�^a�c������-v*9_�����y w�]�j"���<�K;�Z�^�<�z����GȘ�w�ffD�ױQJ?�<�E侃��z'n X�������*/������ʣ���J��,.%sx��]�����S�0�X|��4,�1*�ʷ^�F$�c1��M��5fO`>g2�wی���[�\8e�t*��$��O:�p /7�:+�i�Z�V��]vUC�5SQ�L��Z&�;�@��(N,C8�C&��hMc�0���G�Z_��YY�֬�@��RR�� u���R� c �.eR�*�E�A���V�pe1���������V��'�څ�ե�kd��K+�Kd���Υ���Ε_�j���J=��ɡd�G���[��H��LeB�
�� �~�N��q����X]�?�=S�� �z�w��J� $�v�G��jp�&�!Ǖ�y��fg5��݆������8H���h���
���M�G�� �E��챺 gc��!r Tr~*㼨
�*�O��5�j2� F��k�r�b�$qJ��OV���fG�Ϩά�oh_}�-��V��>1��h
���/ӈ@� ��dq������_N�1V@����|�s c��)�1����OL,��#�Rrlj2�]bzL���_eP+p����� ���|\�nm� �]:{h#�:����' ��z��$ x_ ��u���S�Z�˚�jF���V�̺[OT�z@!!��ߛ^:gv� �}��ݳ !asmn�S�Tw�%΅�DgU �'S.MU8�I"�䣁�mO��)&��PSM���[���+=��=�㾹��فƑ���u2�5�Pﺲ ��,�k���p)��/ |f���\��'Y3����۶�;���);�GǑ�E��� PK ��h\����a o7 scripts/package_skill.py�;kSY���W\���ʁufw���
W�&�Fpgf�HӪ[�CUfmf�Xm8�ݢ�qU|��[�{yt�-�C~̒Yŧ� {�#3o>���݈�Te�s��{^��r��b��4� �Q�j��є$I)�����\��5��x��-���;u �֯=u��3�r&眍��� ��3�# "�ՊE����������ګ���g�n>M �s����)g{bw~�ঠ�#2"�n�s_�����}��6��$�����2���v}�*��������m��{w�m�w2�=x�N�8KS�������i*CJ+�
�F����F*�V��l\*�"����B��j ��*�F �U{��]@|� <��Z��a��)Ͳ[�@� ౪V*�jA��3��-��,����1 ��o���ݕ��l���T ��k��3t�(�t�3�����#s��D+���@DKg�1��te�Hc4%��|l�<P �� H���{% Ţ<�M � ���}�qz�b�+��3��}G��Lm���j�f8�-;oT@G/T
l ̄�ь�H� ea\ ����4�r$����Ȍb+�z��âeV�B�? �7�i�V���A�9 o���6�@� C�LN������JS����r�l�n��z��jq���{�<{��|Y��r }�46c '�] �Qʦ����0l�Ͷ?н�:�v����q_�q�>E��C�����7�Ðw�ev6������ �v��Զ���{;k7�
��=1���5�+bU�&bD���&?p�d��Ȕr��!�F��| �IтD6�++gje[!����V�t%#��u���Mwg?�??<�I�Q�����E�PZ�D�6.F�����F�a�P�,��|(�W��x�s�����T=��U�rY5�n'~y( �mG��U)#�K���� LlWL=��H'WxDՌNJI�9�#c#�K�@���9
�Sv90&�ȯ�3����ɅE:
븵]{�N4Q�����V�@�nWoԗ>4���`�����g/���
ΏC�v���dB��X��5��/��t&�
�A��w��Y��u�5�FE�w��ς�>z �'�wr%�N�k����*�/$j6�}g�>�o��_�v؊��A]��=N'�,h�J���fgk� p��
�J���S�n���/�;َa�/a����g����Z��U�'��g����9 �uaF'yK�Jj�{F�q�v�-!d-��j�IY� +�g��=�Nɥ|����ϴ��6ݜ�ܵ��U��ީ�eP��V����A.�$K:1�al��`)��hz�X��+hE��vA��s4
=ǡlsh( e�ӫ��Y&˭��ܙ|T��)���QX���>S_]v>]kEt/ݨͭ9� ٻ ��|�HM���Zؐ�'^�9�߲�
�0�9A��B
3]�,Tt�BS��`r!HG
��g@�2���m5�,*�d{x�.��FpS�"�aZAkN6f�����T��k��M5gk�2��Ö��T Ҍ��|���
p�Z�v�)l �9Q������W�� ��%�k�d��Y�<������M��"���pJ���p�0��,
�[{�1OԾ�W�Z��a J�Ҿ Kj��˂H^��B��I7�É� L��,3�&��YbX���<��sz>��� CF�����XP���t���/~�ܻ������ g�1d�$�0sW��Z`��G#�Nc���S0�� Q���� ��=���/�}��N)�㽧�3 ��t�r�lOWwd�L��}����C�?~�W�?��W���L�X¼�|� rGwm��=�l�u�~t���� щ�?u�G�w� ?���{R��ƈY�dg{�Y��o�6����� P��l��/����}� x�6��b�k�ۋ�c��{�G�K�8j�{�)�� s/����!P�nЧ4�s�~��-(i�|%�QL\��Cb���ޔ��� �
V��L6�C��������(��3���IPfpŲ4Ԡ�4���@�^C�LI�$04 �C�����,��Ԡ �Z�~���q� V �g��}��:�K3�N����)0 q]>�ǿ�xٙ�^� �v��7HY�,�.��fP&��R@��V�0�YT����R�\(7������&�d�i���<F^��Y76b#�lb�>!��^-9KO�2 ��;��'F�k��d+#�B�����PȲ�9�� �fB勿Łn�rJ,�2a&4P�1��}�\����3b ����' ���d� _����T둀�(�*M�Et���q���g`D ���,� C���6M/��K�r5,_ �<����W� l�?�s��s@<�t�+��0��L�t���[�F�Y{�>�[c�w #`r ���.̈́�\6�A�E șQӇW^7�����9ri�z�V��� g�CD��Q�0�Zu�=D(/�uI����0��<�݃O��<�x�t��q<^ǎ1� ,��oE4�)�(}�Dq�c5�i�c:���o���Ca�z5���\r�a�f��>j� P
ِ�㘔I���I��,��H�Q =��a%���q��}+҆u0�,`O>o�C1nÇ6�� �v�'��m�Yt8�����
KZ|t��+�eG}�Ǻ����C^�/ar|b��2������[
=�dm�=n]��..D������-greg���=>!��Kv��9���i���Sݿ �sE�88Ț����� <Ϧ���~�r���|V{R��|� ������ ��>NA�q��-��1e��y��]�-[-ۘH����F{<�xs�^O/-DS����3��Wks�k�����}
�/@q�b�ߨAz�d��� 'uu�aaŒ�O��2�}G�3 {um�6s�y��3�������ݵ��I��`���w,̐�.B&T0 ��Ym3+:=�[z��d�Qi6
�}�I �6����
g��fS��/a|1ks���l�"5Z�Hm�dh��vn�i�ZDG;|����Mwvq����w�S)��o eܽz�� �w�n�f�~謾q&V;�.����*Ʋ�����T�g�?_�&�OߤRm� �sT����������wϜ�ٝO��̦R��{g����+��r}y�{m��ߑNy�,����#1GC+ڌ<fB�Rl|�N�=N�L9�iզ&��U$RҒ&��Z��;)
UQ�I���>�����n��3��
үQ�<�| JC�@�˗@���:�!$>� �� �m �%�#_h�#melR�P�ӆe�ym#z�,��0���hEt�Z�E~�%K�}�PH�j6�`�: ��$���a�z![��Y�%1����*��X��?d��(W,y{YT�)u�� Ό�/� Z��~���� �,8�_���U+�s�����"i �A ����}�Ա��.�ґ�p�mP��|� .��!)��H!�E��H��j�
�jɛ9�J:�P �$N'<3]���� Ҡx����ΫR�����. UA?25�{�R�8,Y�pǑߡC�|E��U�KPK��əR ~��g᭳r��q�f�|�p}�O�����Ҋ��^��K�H�#
���q(|S�:��Q�e)��ar��!P
wK��3I��=y��� �pC���eN�[d�%�lI�&~�}��k>�=�� ���iv���.�l�q�7��7�\ ��!\cP��k��C�%�@.�F���a�&.5Ib~E(ĊF\��h�J�g"9)ӂ(�?8�� }c*GB Ptd?��d�k�Q�4Ըg�ը#J�� @���8K�M<�
rb���^���xQo���W.� -�� �G0"�.{s�H�����g�tms�Y�)#� �/� ��Ǻa�ᤦ,qD<G����t"Bg�h�����86Of�ow�i}�Ɓ�5�;tû�܂ߩ0+�����-G������!a�[8��
�J��o������荼�F�e�CdX��O5ޚX�pn������� ���}y��vca�z��*�3��6�tG+km��e"��nǒ���W�mU��
�W)�Ċ��*9rjފ8 ���pv:���v Ñ��DlW�;rQ�拄
G��A3#��� �5vn�Ew7"]��A�1�O�s��{ �-ۿP��l]��
�{g� ��"�ګq�K54ń5������!�M���rCJ�73����]�X�~-�I8�P<}����g�C���o?�zZ��l��ܿ�*~��L�4�� �X�TM���[�j�U����'�z��c�p���:\��K����X%�B/�d}*}�XW�� \,��@�ٸ���,ɦ ���t��=�"��6 חX����#U{��,E�?�h2�}��"Y���. �;x��b��� Q�ϲ��Ս6����� ����;?����!j3�b%w���KT3�5�j>��� �<ɡ��ē�Yz!�5+���j�N�<�����s���~���q�� ��sX�웁�ۅ�S|���\d3Z�lF�a�K�l�]|������ho�K�V/�f��
�/�X����OH!NH���/ 1ɑ<ʼf$�ŪV�f�h� V g�Nb�% L�x�/i�o�At�3�1�Ǥ��$�g)�E��8T��ϰ�� ��0 �6K�p�
wF D���CC���~��"�C\��7����ԗ�Y�d�:��?�D����/������/D�\:�7��)X`E!y����RN�������PK ��h\;78��
8# scripts/scheduler.py�]o���]�b�yu����*`�n�p>_'(
�J�ɕń w[ܷ��'��~Ig�{I��)�E��������� o_��kV%���6�w�(�&�B�KFk֒�l�9�DSQ�r��n�#\���dr��vM+�Y���_8�/ĖdM�)ޖ��`�WZ�dr�6�/v%���,��t ����;��"#˶�.x�(����=�̛�<7�<|���d�6�A QT ��0����T�ؖŭ�{?Ն��PB�~QdbN�
.&�IVRΕ)������dv���������!��lCҴ� ��1g�f�M�������,�uS��� �K<0��s ��1�ڕ"� �YH�zii횀A�����KM�lh��%�s� �H3��3��tK�� �\<���ɦ��Bdi0�������`;Z� gm ��u�6_d*�#�@W� T ;2s� ��i�e���o�������u�ٸN0N#� �u��G+ �u`�+ ����� �� ����:�U\���?�6;V v!��=j��6�f��s�H
��j=0�j홀ӯ�3�\iv�a���v�V��i�?jZ���G�|�4���h�>�(yW��6ǩ��qN@Ѣ�Y-�'^@�\�C ����2���l
pK�:�e�]RH^�$��W��jvh?�?�^g���,� %5�?����:։P�~�� � v�q� � v�c�����=H�* �'L��� ��l� ���ۄ\/Ҷ�a��)� ̮J�-��'K�Vl��9���HBM�b/��G/����B���_yւHͻ�� *TY$�-��qH��D������O�����@��z�t+K~̒���ɻm$ $���=9yG�M�r�8d6����t��6��3�� #k���⭗����* ���������qǏ�e5)x�E��P� ]� C�(�����/���qV���� K ,Z��4�P3u�X��jt�y9;��)� $4$����ˣ 0
���! �{��^�T�X�o����w 0e_�S���� -}Jn��Qd)��|`Y'�Z��G��n�p}�2���N&�`kL��x�Z ���|��5-f�CW�x��6Iq�֙������q@�ƶ?�Rq�%���lz����ç�)�H����32=��<����]~���:8?��ژ�j0t�s�^W�vN�o�y1��)��i:�J���9�� �������:p�%Q7��]Q3_.0�ʮ2 �ƪC�(�kɠ��l��LBkZ������.gi���"�\�%"(J7L�S���.��8�}d9$ �b]�� ���b�d�{G�z���u#��2��\}�&g�� ��!� Zx��+pd����|�_�����'���A�0�*3�+ u�4�, �O;�=˳-YA7�r�{=�TA�
�lI_��HqU��WY�ނ��)�¶������Y]��[
I �=_�ͦ����=2c�rq� 2�+�i��}a��hQԝw����2:Z��OW;��p�F3#��v(�U<l��o�FC����0 T,��X�0L�&o J�aX.�GEJV�Y�$a���rD2���J��l|-�w(5{��N�K���n��!]��eۂd�W��4,ES(��ؘ�<. zS5THmfP�L�?*PBA{y$�ڦ~-Y��Y�Rܛh�5�
��!
5Rg�ȅt����Q:��/�' ����m�<������O�͏��O�����ox ��2���Av��
� � ��e��B���-����I �s�4�dg�h$�"�
VD�p�"���
9!��v���d6.� 䅺���o���4x��Z@Y+��r3f�+
�[ ��EēR�# ��䰅U���^$������ � ��6��@n�D�q!o�˦Ws�������ӿU) �Z��mk��ԛ� ./>]]^��g7?�LO�1��]��ST�m�fuW�j�2Ü��'��� o���M.u���c%Uu��o���}jk�a�I�&@V��q=Ғã�($laǯ�xcGژ�(��T(h�jq�J�qK�bj��L�qN0� A�֓� ݴ���n�� �P��^���A+�hJY�59V=9���υɩ*^ݫ��&��}( ߝxY_� ]�qo6x\�M'�h 7Q���8���f�}4� Xr�m6LN�E '��R��} - ���G�; ���N>"e����w &��r'���Bv�h�U�9i!�9)�4�h�P�X8�"��[V����k#*�n5<r ]��r�e
zK���m��+��P�,�iX� �ĭ�<[rc�T$�5vh=�����Y�<�%-`����9Z�9L{�1��7fjw�n;6�{��+M���x̽2���,#�l�@I�˕�!t-;���n|(�; � �������%� N�$3� ����LM��� <�c8k!��+A.j�`�� �=;
���5/fJ/
y[Q��|xq���u�Y��~f��j{w�F.K�x �[>P��J\4-�l�ڹ#g � B�dp�ǣ���r��`�6�B�Ƨgxʝ�DZ���zÁV^F�_��}��[\Jtj�:�%&d��F�/ۇ-o�c���R3�'��] �H^+b_Y�H�CF�oo�c��]_��75��S��%=�ޫ_~Z��tz�� ��M�@�.���7 ó�I ��3������z嚆��������2
8{�w▨7��I���O���u�k��ޚ���U���*�[.;�q���<�c�ӭ��� ��4��|t~�)��3)�S��i*ɦ)�ui��b��
�no6�?PK ڻh\n\�b -Q scripts/skill_bootstrap.py�<ksǖ�]��Б�JR� �dS�r� CrYH�b��|]S�4�'Ȓvf�RT� ~�
��1 \$�d�`��/�f$b����3��3#�ν��[��s��y�9����Ίev�5��z�<*��C��֖D"���{�(�{��m٦VF �r���:�{w��Ŷ�5�n�ˏ���[[Z[�;w��O�w��Ju�>�ֹ�lA��ܩQ53N�>~�,.W77���U�/����o1\}�z���뭙��������o�8���d��q��C�Q�6�9ڙz����Zhm�@��O��e��Q��i���lm{�<&�F�ܵMg�![_[u^]q&�#k�Rʚ=DѬ-;/r�=wƷ���������/ɳ�֝�{㵅+�7��WW�����������K���SR����{�Yu�;��x��b �K��J��S�/4;_2�[[�fi�
�Y����'�H�(zN�m�T�
���R.����8BkmiC�p�3a�1K��e��Nu�[����߽ޚ��\�n�U�gݛ���X���zk���������~��S�u���E]�Rk 䯋�� J��>9�l����ж�� �^�F[�Z����$m{�o�1M� �m�� ;��� m=s����u�z���|듧���xo��y�6����#��_���]���<�����M�h��u��� ¶ӎ�FA���T���A�O�0!L�pf�;W����X�A�A�j[�j�vo��~s��C���_�b�t�B �w՞M�J ���ڝ������{{N�@ u�"#O�E��Ō`��]�J,;W�� =�9�u��N��ELJ�P��R�U����6��hdK9�x��5͒�!nC����`>l�������[W *F&�}��(� ���
��Z� 2�H�oŰ�a+��(�@��TL nVOI�� �`6�w��_/�w����̜����0?wrwؽ�u����$�S-�hQ4+���8�\�#������ ;מb�_�� �6�5��JjV�0��(�ؘL+9���gM�3\�h���(5[*Z���
���}�ɴ3s�7>w�3�/���+��B�>�{�� ���������wc�|���/��P��39[���a��� ��TZ)�.�f*���P�Q��4R
�o �>����{� q �l��(Y���V�G
&���ǕF����\݈�n��X7��BA� DwWzu��v�b�+vϙ��G z+M�9��� S�{uֽ��� |Z'����4�<�,Ͷ�T�������]� �~���4JJ�~�>q�/8�*c����0
� ݏ����;��N2��e�˷��n���0 ��gV�p��^�5�U�o� �0d�0?z���!Y�& �X�yɽ�����-w�N}�1(���4���-ைF�~p �*?��ܹ��#v�ǥ�6�C��i��Y0Jp���#�)K/�y��ߊE�VM<vƏ4�I,:��Gb�����X?&��LD=��Fς� Ӗ/I�s��� �V��*r�0KEeP�S�c'zO�=��wt�c����>���+I�}&m,�$?�Bi�μ �a\u�+�D�o�e������s\����C@aT�W>�� s ]b�^N��,��4O([�¤�$B���h�3I��Ӽ@e8r��鶞��@��!���? e��2���ڽg{ k���V�NH�:O ;�p�����l��b��oj�n��p���0��k�ц�q
�&4�z����˹vg��5$�B���N�g�������$8���,��CqXA�+ ��8Ë6K"��=�zDA��
��;kK��Ex�\�r�_D�����;�V]��� �;2�Q����6�S)?~[�sW��`� ��ix:�����nW̢�I�^A�e��%�ׄ�8q���/"���BUJ� ����0� ��V�9�&�%�Ɣ�/�Bљ�����
F�Wl I�B%2�)^���ĕ���9�?�"0� ���A]��]N��(�\b� � G4����̝��{�����V�I�5@1ŝ[vo=kqz!P�*c�!��6L�� *يi�E�6����x��Mɫ$���l�Z���T���
Jg�����N�*glDQ�0��Y�(۞&S���8 �����l��� ���G�Ϊ� �x�6�` @��){���I�Lx�M*�~ps�� �
�f&h�A͌�ě� �!�B��p�EPFc?b{1Fw�ݞ�
` ��rL!�U��43;�(��K7v�$_��aօ
�J6�[�_w }�}�4Ѐ�iZ �y K��xሼj�bQA?��X)��ʰnb�H�cB�ћ�/3k�?sd T5�%��<G/�R�adC4�j�Y��P�b�����;� 1��D���c�
蟸 ���Hf���ی� �J�^Ȣ���V,����s�i�m�7�&^�f��/��9��Q�K6߇-�TP�� A A1��_��ʰ���j�T�Ƀ���$3�F�(��Y�UA" ]t����(�&>��eL��w�9s����s�P�qU<��=ݧ�c�p�,C�WH� �d�1�t# ��ӻ�!y�fǍ��H��bG�8���=�ێN���t�\�4�/M�uSR)a�^C��\�|<�R1o ��r+I��)!���N��)�* �T���4ɚp� ^��.U��Ĺ�U2�3 ��U1��|��J�Kp�kǓk�����4�Y�C��?�g*W�~��Wu�>������p�p�tR�jl��茁�9��#�6��X�!o�8Y%9�?[�Ą8 ��i��t��������-9�����"�x�T��a1�
|Q{�k b _l~���``�=�����%$�F��?�)RVژ; �L����������� � ��7(d}u
�\�)wuJ:��<FF.l���H�@ў� 5ZL?[*�:� ��Q;!u��Iw~����IE^b����{߱�5,;|������c ��P��vo����V7_�hR�H�Y�.E�(��:P *�9yM�{�����ٯf����>�R i$[b�L�,
��eI�B`̘�
)�>������� �$�XKY�j)U�`w%����NO�y��}>�ʩٶ߁FV%����W
� ~T��t�a�1# �n�Di)� ������x}s'_�m�?c[�x��C���s��/��=���2
�kp��G"�m�h����˓�Q�lR�ͥ���y��D0��ă�a��M��-�_�7�� Rg�Ǭ�^��)�M;u�]�O��>���� �T�>����[C��;��F�c`JP�h�6P�f4�� �5vk��eJ�0��_��mY�jhQc<� �"r�%� �jGݶmg+6 �j�SS^�|n�D���2p#��8�V��Kp �7=��l�`��~��*�.�l����Z���4�p G�d ��abOT2Gz�=��L\w� ��؏�8����$������n���1� z"�0^UlQ���5��-g�c�b����w�O�K�����.��h���ĥ��ʰ�Yɼ�D?3�
�e���D̰�E=[����Љ�U� C ,�?+F��
qZS��\ۈEi6,�ڟ9:�N�`r�hu���]nPIfBdҟ �G��$9Ps鲘��3�n��tL����F��ȇ�zB�\���G�|���Ȉ�@����&sJj�5�@�'-*�h� ȇ
�2��ɈH
�v�3��b�ҽy�1YSL ��dYԚxC&g_� 8� :/_�W_ݫ�8�g�͍�ʊ`q��XD���J�7�ۇ$UK� � ��?A)p����O���I���Se��)rP�`�lZ�+ �4b*��I� ?;��2r�|�:5v� ]�
�< �}�:������mʐ�7��_얼�gz�y٨�o��KH
��a �Q��F��y1���]������� wtL�����A|B�](2|��a�(���y�`�1�,=���uq<A=4����}$�O'~�?�ח��� {�D�a(�eN�� ���� @&�
5�+�U����ه'��F?�����ys�ܴ�E��[ ! a��� 8BZݜ��� V����Q8��F(�C��N��G �A"��F���
�z8C�!Q�ܜ���ϧ?"��(7�_�(��$|D����G� ;x���#�\�?�֙��,��2����S�;f|� G`�%�w+a8��mm�u�"�(ţ�5������̸�?��$uXw�� ���`�1�R�� Q�_of8fƝ��#�������:
�R�#���_� 峒QLQ��b\P���A�>� ��C��l��s�K8�,^S!���#��&����6x3�O��2��Рș� ���6k��\;��lOb;��<��Nn>��}����x����� ��<� �!To����� ��M �6m�S�x\���h�?��1��q t�<:�n�� �.�����
A� �nC�� =� ���4��nE�E��S$JR�`��` �B�O��e�O��D���Np杌���l�_3��.� �>��Fv���k�/��k�� :u�5
���ր<Z �2�o ���|r�) �/�wÇ̑M�5�ݱ g|�\g�|�L$�܀��þnCE�7�G��'/)����
�����E���J����qۅ^15|m� ��,��66Hu}�����"$��g} {3r;�=��ht.��`�9�{�%��H��wgƢ�[�9
�+ ��@ H��H�#+�@gp�
Oyl.�V7�#�i {L9
��d� m�;"j�/ݕ)�
�g|��qԿ�|]}5�ڢ���Y��C1�s���[u�}6�0���R4⊻�%Xi|��4;����x��Y����"��ثD<��� իK"�;b���A��@�I�g�^��0�w�0u���݀�#�r�E��E?R���P�wT����XI ��/,����yJ�m�۞!2ay#��PB4��H��ֽ��x�U^�� ��2W�fB g� p��hS������H�!�>~Q. �S�}�]o;� �2��h�EX/Zb� h�ݰSo�%y�IV�����"|(M�6�11�G�D�< Z桄=pJ-�S$#�7�}D�IM��h��e� o\%9 u�3��`���G����(���˃=�#�_��U[�R}��ή�H�VLf2�n;���j��ٮ����2^%��B��П䚓a(y����y�>#�eb�JuQa�:�_�j\��mb��;vY�k89����_{��ղC�B~|���=�!��^��7J�dž���9M-��# l/��3�g�� � @��#�zJ�=��.�sY�G iY&�Y�;�c�Y��S�*rw��3po�7��rT5�F �����ceGSB�s(�-� �E��7��dm�J5 ��/�d��Vzo���\t[QUi!GU�5���^%�MxSu}�C���k]�[f|O z���e� v��➼
�l*ij��OR9 ��8l�J �J�zBo\��em�_�8x-�S5�0��蠯)H�#-K&-���JߐЎ��B�+�8E_{ �J6�IJ 0�=0��/�� ��8=6�G���4���z �2^�D(�E�*05�-���9)�" C=���*����8���aC���>�w��sp���𦜄���;�%��>�@����U H�� ,��M�F�PK ��h\:T Y �� AGENT_QUICK_REF.txtPK ��h\9�-h � ��6 ENCODING_FIX_SUMMARY.mdPK ��h\��#{
.! ��� FIXES.mdPK h�h\���\
��t" INSTALL.mdPK ��h\�= ~� - ���. NO_PYTHON_GUIDE.mdPK ��h\@,�& � ���8 PROGRESSIVE_SCAN_SUMMARY.mdPK ��h\�;V�| ]
��B README.txtPK ��h\3w�� )
���D skill.jsonPK ��h\ ��A, �� ���E SKILL.mdPK �h\�6v'�
0 ��r UNIVERSAL_INSTALL.mdPK 4�h\�r
E � ���| diskcleaner/__init__.pyPK 4�h\n��� h �� ~ diskcleaner/config/defaults.pyPK 4�h\p���J
�) ��K� diskcleaner/config/loader.pyPK 4�h\r��,r � ��ύ diskcleaner/config/__init__.pyPK 4�h\5DxA� ��}� diskcleaner/core/cache.pyPK 4�h\�� fP �% ��:� diskcleaner/core/classifier.pyPK 4�h\͙�hK B# $ ��Ɵ diskcleaner/core/duplicate_finder.pyPK 4�h\���K �` ��S� diskcleaner/core/interactive.pyPK 4�h\��� H2 # ��۽ diskcleaner/core/process_manager.pyPK 4�h\���d�
�( ���� diskcleaner/core/progress.pyPK 4�h\_��w* �4 ���� diskcleaner/core/safety.pyPK 4�h\�\�� 'C ���� diskcleaner/core/scanner.pyPK 4�h\Աɶ� �, ! ��� diskcleaner/core/smart_cleanup.pyPK 4�h\�|�G � ��U� diskcleaner/core/__init__.pyPK 4�h\u��L K ' ���� diskcleaner/optimization/concurrency.pyPK 4�h\���T �C " ��g diskcleaner/optimization/delete.pyPK 4�h\�u$w0 �I ��� diskcleaner/optimization/hash.pyPK 4�h\3K�)H � " ��i& diskcleaner/optimization/memory.pyPK 4�h\\��g� R $ ���, diskcleaner/optimization/profiler.pyPK 4�h\�3� �F ��14 diskcleaner/optimization/scan.pyPK 4�h\
��rG � $ ���E diskcleaner/optimization/__init__.pyPK 4�h\�J7�� � �� H diskcleaner/platforms/linux.pyPK 4�h\{�U�� � ��&N diskcleaner/platforms/macos.pyPK 4�h\o�Q�� � ��,T diskcleaner/platforms/windows.pyPK 4�h\M�{� ! ��Z diskcleaner/platforms/__init__.pyPK 4�h\ڍ�; 8 ���Z references/temp_locations.mdPK ��h\�- �8 TW ��Ga scripts/analyze_disk.pyPK b�h\��� �@ ���y scripts/analyze_progressive.pyPK ��h\of� �$ ��ڋ scripts/check_skill.pyPK m�h\)�&� a ��� scripts/clean_disk.pyPK ��h\$I�m� 1 ��� scripts/monitor_disk.pyPK ��h\����a o7 ��� scripts/package_skill.pyPK ��h\;78��
8# ���� scripts/scheduler.pyPK ڻh\n\�b -Q ���� scripts/skill_bootstrap.pyPK , , d � diskcleaner/__init__.py
"""
disk-cleaner - Cross-platform disk space management toolkit
A comprehensive toolkit for monitoring, analyzing, and cleaning disk space
safely across Windows, Linux, and macOS.
"""
__version__ = "2.0.0-dev"
__author__ = "Disk Cleaner Contributors"
from diskcleaner.config import Config
from diskcleaner.core import DirectoryScanner, FileClassifier, SafetyChecker
__all__ = [
"DirectoryScanner",
"FileClassifier",
"SafetyChecker",
"Config",
]
diskcleaner/config/__init__.py
"""
Configuration management
"""
from diskcleaner.config.defaults import get_default_config
from diskcleaner.config.loader import Config
__all__ = [
"Config",
"get_default_config",
]
diskcleaner/config/defaults.py
"""
Default configuration for disk-cleaner.
This module provides default configuration values that can be overridden
by user config files or command-line arguments.
"""
from typing import Dict, List
def get_default_config() -> Dict:
"""
Get default configuration.
Returns:
Dictionary with default configuration values.
"""
return {
# Protected paths and files
"protected": {
"paths": [
# Windows
"C:\\Windows",
"C:\\Program Files",
"C:\\Program Files (x86)",
"C:\\ProgramData",
# Linux/macOS
"/usr",
"/bin",
"/sbin",
"/lib",
"/System",
"/Library",
],
"patterns": [
"*.database",
"*.db",
"*.sqlite",
"*.sqlite3",
"config.*",
"*.config",
"*.conf",
],
},
# Cleaning rules
"rules": [
{
"name": "Old logs",
"pattern": "*.log",
"category": "Logs",
"risk": "safe",
"age_threshold": 60, # days
},
{
"name": "Build artifacts",
"pattern": "node_modules/",
"category": "Build",
"risk": "safe",
"age_threshold": 0,
},
{
"name": "Python cache",
"pattern": "__pycache__/",
"category": "Cache",
"risk": "safe",
"age_threshold": 0,
},
{
"name": "Python bytecode",
"pattern": "*.pyc",
"category": "Cache",
"risk": "safe",
"age_threshold": 0,
},
{
"name": "Temporary files",
"pattern": "*.tmp",
"category": "Temp",
"risk": "safe",
"age_threshold": 0,
},
],
# Ignore rules (exclude from scanning)
"ignore": [
".git/*",
".svn/*",
".hg/*",
"node_modules/@types",
"*.lock",
],
# Safety settings
"safety": {
"check_file_locks": True,
"verify_permissions": True,
"backup_before_delete": False,
"protected_extensions": [
# Windows executables
".exe",
".dll",
".sys",
".drv",
".bat",
".cmd",
".ps1",
".vbs",
# Unix executables
".sh",
".bash",
".zsh",
".fish",
# macOS
".app",
".dmg",
".pkg",
# Linux
".deb",
".rpm",
# Installers and images
".msi",
".iso",
".vhd",
".vhdx",
".vmdk",
],
},
# Scan settings
"scan": {
"use_incremental": True,
"cache_dir": "~/.disk-cleaner/cache",
"cache_ttl": 7, # days
"parallel_jobs": 4,
"follow_symlinks": False,
"max_depth": None, # None = unlimited
},
# Platform-specific features
"platform_features": {
"enabled": True,
"auto_include": False, # Don't auto-include in cleanup list
},
# Notifications
"notifications": {
"enabled": False,
"webhook_url": "",
"on_completion": True,
"on_error": True,
},
# Display settings
"display": {
"show_hidden": False,
"human_readable": True,
"date_format": "%Y-%m-%d %H:%M",
"max_file_list": 100, # Max files to display in detailed view
},
}
def get_protected_extensions() -> List[str]:
"""
Get list of protected file extensions.
Returns:
List of file extensions that should never be deleted.
"""
return get_default_config()["safety"]["protected_extensions"]
def get_protected_paths() -> List[str]:
"""
Get list of protected system paths.
Returns:
List of paths that should never be scanned/deleted.
"""
return get_default_config()["protected"]["paths"]
diskcleaner/config/loader.py
"""
Configuration loader with multi-level priority support.
Loads configuration from multiple sources with priority:
1. Command-line arguments (highest)
2. Project directory (.disk-cleaner.yaml)
3. User config (~/.disk-cleaner/config.yaml)
4. Default config (lowest)
"""
from pathlib import Path
from typing import Any, Dict, List, Optional
from diskcleaner.config.defaults import get_default_config
class Config:
"""
Configuration manager with multi-level priority support.
Usage:
config = Config.load(
path="/path/to/project",
cli_args={"age_threshold": 90}
)
"""
def __init__(self, config: Dict[str, Any]):
"""
Initialize configuration.
Args:
config: Configuration dictionary.
"""
self._config = config
@classmethod
def load(
cls,
path: Optional[str] = None,
cli_args: Optional[Dict[str, Any]] = None,
) -> "Config":
"""
Load configuration with proper priority merging.
Args:
path: Project path to look for .disk-cleaner.yaml
cli_args: Command-line arguments (highest priority)
Returns:
Config instance with merged configuration.
"""
# Start with default config
config = get_default_config()
# Load and merge user config
user_config = cls._load_user_config()
config = cls._merge_configs(config, user_config)
# Load and merge project config
if path:
project_config = cls._load_project_config(path)
config = cls._merge_configs(config, project_config)
# Apply command-line arguments (highest priority)
if cli_args:
config = cls._apply_cli_args(config, cli_args)
return cls(config)
@staticmethod
def _load_user_config() -> Dict[str, Any]:
"""
Load user configuration from ~/.disk-cleaner/config.yaml.
Returns:
User config dict, or empty dict if not found.
"""
config_path = Path.home() / ".disk-cleaner" / "config.yaml"
if not config_path.exists():
return {}
return Config._load_yaml_file(config_path)
@staticmethod
def _load_project_config(project_path: str) -> Dict[str, Any]:
"""
Load project configuration from .disk-cleaner.yaml.
Args:
project_path: Path to project directory.
Returns:
Project config dict, or empty dict if not found.
"""
project_dir = Path(project_path)
# Look for .disk-cleaner.yaml in project root
config_path = project_dir / ".disk-cleaner.yaml"
if not config_path.exists():
# Also try disk-cleaner.yaml (without dot)
config_path = project_dir / "disk-cleaner.yaml"
if not config_path.exists():
return {}
return Config._load_yaml_file(config_path)
@staticmethod
def _load_yaml_file(file_path: Path) -> Dict[str, Any]:
"""
Load YAML file without external dependencies.
Args:
file_path: Path to YAML file.
Returns:
Parsed YAML as dict, or empty dict on error.
"""
try:
with open(file_path, "r", encoding="utf-8") as f:
content = f.read()
# Simple YAML parser for our config format
# This avoids requiring pyyaml dependency
return Config._parse_simple_yaml(content)
except (OSError, IOError):
return {}
@staticmethod
def _parse_simple_yaml(content: str) -> Dict[str, Any]:
"""
Parse simplified YAML format.
This is a basic YAML parser that handles our config format.
It supports:
- Key-value pairs
- Nested dictionaries
- Lists
- Comments (#)
Args:
content: YAML content as string.
Returns:
Parsed configuration as dict.
"""
config: Dict[str, Any] = {}
stack: list = [config]
current = config
indent_size = 0
for line in content.split("\n"):
# Skip empty lines and comments
stripped = line.strip()
if not stripped or stripped.startswith("#"):
continue
# Calculate indentation
indent = len(line) - len(line.lstrip())
# Adjust stack based on indentation
if indent == 0:
stack = [config]
current = config
elif indent > indent_size:
# Deeper level, but we should have already created the parent
pass
elif indent < indent_size:
# Shallower level, pop stack
while len(stack) > 1 and indent < len(stack[-1]) * 2:
stack.pop()
current = stack[-1]
indent_size = indent
# Parse key-value pair
if ":" in stripped:
key, value = stripped.split(":", 1)
key = key.strip()
value = value.strip()
if not value:
# This is a parent key for nested values
current[key] = {}
stack.append(current[key])
current = current[key]
elif value.startswith("[") and value.endswith("]"):
# List value
list_str = value[1:-1]
current[key] = [item.strip().strip("\"'") for item in list_str.split(",")]
else:
# Simple value
# Try to parse as Python literal
value = value.strip("\"'")
if value.lower() == "true":
value = True
elif value.lower() == "false":
value = False
elif value.lower() == "null" or value.lower() == "none":
value = None
elif value.isdigit():
value = int(value)
else:
# Try float
try:
value = float(value)
except ValueError:
pass
current[key] = value
return config
@staticmethod
def _merge_configs(base: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any]:
"""
Deep merge two config dictionaries.
Args:
base: Base configuration.
override: Override configuration (higher priority).
Returns:
Merged configuration.
"""
result = base.copy()
for key, value in override.items():
if key in result and isinstance(result[key], dict) and isinstance(value, dict):
# Recursively merge nested dicts
result[key] = Config._merge_configs(result[key], value)
else:
# Override with higher priority value
result[key] = value
return result
@staticmethod
def _apply_cli_args(config: Dict[str, Any], cli_args: Dict[str, Any]) -> Dict[str, Any]:
"""
Apply command-line arguments to config.
Args:
config: Current configuration.
cli_args: Command-line arguments.
Returns:
Updated configuration.
"""
# CLI args have highest priority, direct override
for key, value in cli_args.items():
# Support nested keys with dot notation
if "." in key:
parts = key.split(".")
current = config
for part in parts[:-1]:
if part not in current:
current[part] = {}
current = current[part]
current[parts[-1]] = value
else:
config[key] = value
return config
def get(self, key: str, default: Any = None) -> Any:
"""
Get configuration value.
Args:
key: Configuration key (supports dot notation for nested values).
default: Default value if key not found.
Returns:
Configuration value, or default if not found.
"""
# Support dot notation for nested keys
parts = key.split(".")
current = self._config
try:
for part in parts:
current = current[part]
return current
except (KeyError, TypeError):
return default
def set(self, key: str, value: Any) -> None:
"""
Set configuration value.
Args:
key: Configuration key (supports dot notation).
value: Value to set.
"""
parts = key.split(".")
current = self._config
# Navigate to parent
for part in parts[:-1]:
if part not in current:
current[part] = {}
current = current[part]
# Set value
current[parts[-1]] = value
@property
def protected_paths(self) -> List[str]:
"""Get protected paths list."""
return self.get("protected.paths", [])
@property
def protected_patterns(self) -> List[str]:
"""Get protected file patterns."""
return self.get("protected.patterns", [])
@property
def protected_extensions(self) -> List[str]:
"""Get protected file extensions."""
return self.get("safety.protected_extensions", [])
@property
def check_file_locks(self) -> bool:
"""Check if file lock detection is enabled."""
return self.get("safety.check_file_locks", True)
@property
def verify_permissions(self) -> bool:
"""Check if permission verification is enabled."""
return self.get("safety.verify_permissions", True)
@property
def use_incremental_scan(self) -> bool:
"""Check if incremental scanning is enabled."""
return self.get("scan.use_incremental", True)
@property
def cache_dir(self) -> str:
"""Get cache directory path."""
return self.get("scan.cache_dir", "~/.disk-cleaner/cache")
@property
def cache_ttl(self) -> int:
"""Get cache TTL in days."""
return self.get("scan.cache_ttl", 7)
def to_dict(self) -> Dict[str, Any]:
"""Get configuration as dictionary."""
return self._config.copy()
diskcleaner/core/__init__.py
"""
Core functionality modules
"""
from diskcleaner.core.cache import CacheManager
from diskcleaner.core.classifier import FileClassifier
from diskcleaner.core.duplicate_finder import DuplicateFinder, DuplicateGroup
from diskcleaner.core.interactive import InteractiveCleanupUI
from diskcleaner.core.process_manager import ProcessInfo, ProcessManager
from diskcleaner.core.progress import IndeterminateProgress, ProgressBar, progress_iterator
from diskcleaner.core.safety import SafetyChecker
from diskcleaner.core.scanner import DirectoryScanner
from diskcleaner.core.smart_cleanup import CleanupReport, SmartCleanupEngine
__all__ = [
"DirectoryScanner",
"FileClassifier",
"SafetyChecker",
"CacheManager",
"DuplicateFinder",
"DuplicateGroup",
"SmartCleanupEngine",
"CleanupReport",
"InteractiveCleanupUI",
"ProcessManager",
"ProcessInfo",
"ProgressBar",
"IndeterminateProgress",
"progress_iterator",
]
diskcleaner/core/cache.py
"""
Cache management for incremental scanning.
This module provides caching functionality to speed up repeated scans
by storing file metadata and detecting changes.
"""
import hashlib
import json
import time
from dataclasses import asdict, dataclass, field
from pathlib import Path
from typing import Dict, List, Optional
@dataclass
class FileSnapshot:
"""Snapshot of a single file's metadata."""
path: str
size: int
mtime: float
inode: Optional[int] = None
def to_dict(self) -> Dict:
"""Convert to dictionary for JSON serialization."""
return asdict(self)
@classmethod
def from_dict(cls, data: Dict) -> "FileSnapshot":
"""Create from dictionary."""
return cls(**data)
def __hash__(self) -> int:
"""Make FileSnapshot hashable for caching."""
return hash((self.path, self.size, self.mtime, self.inode))
@dataclass
class ScanSnapshot:
"""Snapshot of an entire directory scan."""
path: str
timestamp: float
files: List[FileSnapshot] = field(default_factory=list)
total_size: int = 0
file_count: int = 0
def to_dict(self) -> Dict:
"""Convert to dictionary for JSON serialization."""
return {
"path": self.path,
"timestamp": self.timestamp,
"files": [f.to_dict() for f in self.files],
"total_size": self.total_size,
"file_count": self.file_count,
}
@classmethod
def from_dict(cls, data: Dict) -> "ScanSnapshot":
"""Create from dictionary."""
return cls(
path=data["path"],
timestamp=data["timestamp"],
files=[FileSnapshot.from_dict(f) for f in data.get("files", [])],
total_size=data.get("total_size", 0),
file_count=data.get("file_count", 0),
)
class CacheManager:
"""Manages scan cache for incremental scanning."""
def __init__(self, cache_dir: str = "~/.disk-cleaner/cache"):
"""
Initialize cache manager.
Args:
cache_dir: Directory to store cache files. Supports ~ expansion.
"""
self.cache_dir = Path(cache_dir).expanduser()
self.cache_dir.mkdir(parents=True, exist_ok=True)
def _get_cache_path(self, scan_path: str) -> Path:
"""
Get cache file path for a given scan path.
Args:
scan_path: The path that was scanned.
Returns:
Path to cache file.
"""
# Use MD5 hash of path as cache filename
path_hash = hashlib.md5(str(scan_path).encode()).hexdigest()
return self.cache_dir / f"{path_hash}.json"
def get_scan_cache(self, path: str, max_age_days: int = 7) -> Optional[ScanSnapshot]:
"""
Retrieve cached scan results.
Args:
path: The path to look up in cache.
max_age_days: Maximum age of cache in days (default: 7).
Returns:
ScanSnapshot if cache exists and is valid, None otherwise.
"""
cache_file = self._get_cache_path(path)
# Check if cache exists
if not cache_file.exists():
return None
# Check if cache has expired
cache_age = time.time() - cache_file.stat().st_mtime
max_age_seconds = max_age_days * 24 * 3600
if cache_age > max_age_seconds:
# Cache expired, delete it
cache_file.unlink()
return None
# Load and return cache
try:
with open(cache_file, "r", encoding="utf-8") as f:
data = json.load(f)
return ScanSnapshot.from_dict(data)
except (json.JSONDecodeError, KeyError, ValueError):
# Invalid cache, delete it
cache_file.unlink()
return None
def save_scan_cache(self, path: str, snapshot: ScanSnapshot) -> None:
"""
Save scan results to cache.
Args:
path: The path that was scanned.
snapshot: The scan snapshot to cache.
"""
cache_file = self._get_cache_path(path)
try:
with open(cache_file, "w", encoding="utf-8") as f:
json.dump(snapshot.to_dict(), f, indent=2)
except (OSError, IOError):
# Silently fail if we can't write cache
# This shouldn't break the scan, just disable caching
pass
def is_file_changed(self, current: FileSnapshot, cached: FileSnapshot) -> bool:
"""
Check if a file has changed since last scan.
Args:
current: Current file snapshot.
cached: Cached file snapshot.
Returns:
True if file has changed, False otherwise.
"""
# Check size first (fastest)
if current.size != cached.size:
return True
# Check modification time
if current.mtime != cached.mtime:
return True
# Check inode if available (Unix systems)
if current.inode is not None and cached.inode is not None:
if current.inode != cached.inode:
return True
return False
def clear_cache(self, path: Optional[str] = None) -> None:
"""
Clear cache.
Args:
path: If specified, only clear cache for this path.
If None, clear all cache.
"""
if path is not None:
cache_file = self._get_cache_path(path)
if cache_file.exists():
cache_file.unlink()
else:
# Clear all cache files
for cache_file in self.cache_dir.glob("*.json"):
cache_file.unlink()
def get_cache_stats(self) -> Dict[str, int]:
"""
Get cache statistics.
Returns:
Dictionary with cache stats (total_files, total_size_mb).
"""
cache_files = list(self.cache_dir.glob("*.json"))
total_size = sum(f.stat().st_size for f in cache_files)
return {
"total_files": len(cache_files),
"total_size_mb": int(round(total_size / (1024 * 1024), 2)),
}
diskcleaner/core/classifier.py
"""
File classifier with multi-dimensional categorization.
Classifies files by type, risk level, and age for intelligent
cleanup recommendations.
"""
import fnmatch
from datetime import datetime, timedelta
from enum import Enum
from pathlib import Path
from typing import Dict, List, Optional
from diskcleaner.config import Config
from diskcleaner.core.scanner import FileInfo
class RiskLevel(Enum):
"""Risk level for file deletion."""
SAFE = "safe"
CONFIRM_NEEDED = "confirm_needed"
PROTECTED = "protected"
class FileClassifier:
"""
Classifies files into categories for intelligent cleanup.
Provides three-dimensional classification:
1. By type (temp, logs, cache, build artifacts, etc.)
2. By risk level (safe, confirm_needed, protected)
3. By age (recent, mid-term, old)
"""
def __init__(self, config: Optional[Config] = None):
"""
Initialize classifier.
Args:
config: Configuration object.
"""
self.config = config or Config.load()
# Load protected patterns and extensions
self.protected_patterns = self.config.protected_patterns
self.protected_extensions = self.config.protected_extensions
self.protected_paths = self.config.protected_paths
# Load custom rules
self.custom_rules = self.config.get("rules", [])
# Define type categories
self.type_categories = {
"临时/构建产物": [
"*.tmp",
"*.temp",
"*.cache",
"__pycache__",
"node_modules",
".pytest_cache",
".mypy_cache",
"*.pyc",
"*.pyo",
],
"日志文件": ["*.log"],
"缓存文件": [
"*.cache",
".cache",
"Thumbs.db",
".DS_Store",
],
"备份文件": [
"*.bak",
"*.backup",
"*~",
"*.old",
],
"下载文件": None, # Special handling by path
"媒体文件": [
"*.mp4",
"*.mkv",
"*.avi",
"*.mov",
"*.mp3",
"*.flac",
"*.jpg",
"*.jpeg",
"*.png",
"*.gif",
"*.bmp",
],
"文档文件": [
"*.pdf",
"*.doc",
"*.docx",
"*.xls",
"*.xlsx",
"*.ppt",
"*.pptx",
"*.odt",
],
"压缩文件": [
"*.zip",
"*.tar",
"*.gz",
"*.rar",
"*.7z",
],
}
def classify(
self,
files: List[FileInfo],
) -> Dict[str, Dict[str, List[FileInfo]]]:
"""
Classify files by type, risk, and age.
Args:
files: List of FileInfo objects to classify.
Returns:
Dictionary with three classification dimensions:
{
"by_type": {category_name: [files]},
"by_risk": {risk_level: [files]},
"by_age": {age_group: [files]}
}
"""
result = {
"by_type": {},
"by_risk": {
RiskLevel.SAFE.value: [],
RiskLevel.CONFIRM_NEEDED.value: [],
RiskLevel.PROTECTED.value: [],
},
"by_age": {
"最近创建 (7天内)": [],
"近期文件 (30天内)": [],
"陈旧文件 (90天内)": [],
"很旧 (90天以上)": [],
},
}
for file in files:
# Skip directories
if file.is_dir:
continue
# Classify by type
type_category = self._classify_type(file)
if type_category not in result["by_type"]:
result["by_type"][type_category] = []
result["by_type"][type_category].append(file)
# Classify by risk
risk_level = self._classify_risk(file)
result["by_risk"][risk_level.value].append(file)
# Classify by age
age_group = self._classify_age(file)
result["by_age"][age_group].append(file)
return result
def _classify_type(self, file: FileInfo) -> str:
"""
Classify file by type.
Args:
file: FileInfo object.
Returns:
Type category name.
"""
# Check custom rules first
for rule in self.custom_rules:
pattern = rule.get("pattern", "")
if self._matches_pattern(file, pattern):
return rule.get("category", "其他文件")
# Check built-in categories
for category, patterns in self.type_categories.items():
if patterns is None:
continue
for pattern in patterns:
if self._matches_pattern(file, pattern):
return category
# Special handling for downloads
if "downloads" in file.path.lower():
return "下载文件"
return "其他文件"
def _classify_risk(self, file: FileInfo) -> RiskLevel:
"""
Classify file by risk level.
Args:
file: FileInfo object.
Returns:
RiskLevel enum value.
"""
# Check if path is protected
for protected_path in self.protected_paths:
if file.path.startswith(protected_path):
return RiskLevel.PROTECTED
# Check if extension is protected
for ext in self.protected_extensions:
if file.name.lower().endswith(ext.lower()):
return RiskLevel.PROTECTED
# Check if pattern matches protected patterns
for pattern in self.protected_patterns:
if fnmatch.fnmatch(file.name, pattern):
return RiskLevel.PROTECTED
# Classify by file type
file_type = self._classify_type(file)
# Safe to delete categories
safe_categories = ["临时/构建产物", "日志文件", "缓存文件"]
if file_type in safe_categories:
return RiskLevel.SAFE
# Confirm needed for user data
confirm_categories = ["下载文件", "媒体文件", "文档文件"]
if file_type in confirm_categories:
return RiskLevel.CONFIRM_NEEDED
# Default to confirm needed
return RiskLevel.CONFIRM_NEEDED
def _classify_age(self, file: FileInfo) -> str:
"""
Classify file by age.
Args:
file: FileInfo object.
Returns:
Age group name.
"""
now = datetime.now()
file_time = datetime.fromtimestamp(file.mtime)
age = now - file_time
if age < timedelta(days=7):
return "最近创建 (7天内)"
elif age < timedelta(days=30):
return "近期文件 (30天内)"
elif age < timedelta(days=90):
return "陈旧文件 (90天内)"
else:
return "很旧 (90天以上)"
def _matches_pattern(self, file: FileInfo, pattern: str) -> bool:
"""
Check if file matches a pattern.
Args:
file: FileInfo object.
pattern: Pattern to match (can be * wildcards or directory names).
Returns:
True if file matches pattern.
"""
# Check filename
if fnmatch.fnmatch(file.name, pattern):
return True
# Check path components
path_parts = Path(file.path).parts
for part in path_parts:
if fnmatch.fnmatch(part, pattern):
return True
# Check full path
if fnmatch.fnmatch(file.path, pattern):
return True
# Check if pattern is a directory name in path
if pattern.rstrip("/") in path_parts:
return True
return False
def get_type_stats(
self,
files: List[FileInfo],
) -> Dict[str, Dict[str, int]]:
"""
Get statistics by file type.
Args:
files: List of FileInfo objects.
Returns:
Dictionary with stats for each type:
{
"type_name": {
"count": 10,
"total_size": 1024000
}
}
"""
classification = self.classify(files)
stats = {}
for type_name, type_files in classification["by_type"].items():
stats[type_name] = {
"count": len(type_files),
"total_size": sum(f.size for f in type_files),
}
return stats
def get_risk_stats(
self,
files: List[FileInfo],
) -> Dict[str, Dict[str, int]]:
"""
Get statistics by risk level.
Args:
files: List of FileInfo objects.
Returns:
Dictionary with stats for each risk level.
"""
classification = self.classify(files)
stats = {}
for risk_level, risk_files in classification["by_risk"].items():
stats[risk_level] = {
"count": len(risk_files),
"total_size": sum(f.size for f in risk_files),
}
return stats
diskcleaner/core/duplicate_finder.py
"""
Duplicate file detector with adaptive strategy.
Detects duplicate files using two strategies:
- Fast: Size + mtime pre-filtering for large directories
- Accurate: SHA-256 hash comparison for smaller directories
"""
import hashlib
from dataclasses import dataclass
from typing import Dict, List, Optional, Tuple
from diskcleaner.core.scanner import FileInfo
@dataclass
class DuplicateGroup:
"""A group of duplicate files."""
files: List[FileInfo]
size: int
hash_value: Optional[str] = None
@property
def count(self) -> int:
"""Number of duplicate files."""
return len(self.files)
@property
def reclaimable_space(self) -> int:
"""Space that can be reclaimed (keeping one copy)."""
return self.size * (self.count - 1)
class DuplicateFinder:
"""
Duplicate file detector with adaptive strategy.
Features:
- Adaptive strategy selection based on file count
- Fast strategy: size + mtime pre-filtering
- Accurate strategy: SHA-256 hash comparison
- Sorted by reclaimable space (descending)
"""
# Threshold for switching strategies
ADAPTIVE_THRESHOLD = 1000
def __init__(self, strategy: str = "adaptive", fast_similarity_threshold: float = 0.95):
"""
Initialize duplicate finder.
Args:
strategy: Detection strategy ('adaptive', 'fast', 'accurate')
fast_similarity_threshold: Min similarity ratio for fast strategy (0-1)
"""
if strategy not in ("adaptive", "fast", "accurate"):
raise ValueError(f"Invalid strategy: {strategy}")
self.strategy = strategy
self.fast_similarity_threshold = fast_similarity_threshold
def find_duplicates(self, files: List[FileInfo]) -> List[DuplicateGroup]:
"""
Find duplicate files in the given list.
Args:
files: List of FileInfo objects to check.
Returns:
List of DuplicateGroup objects, sorted by reclaimable space.
"""
if not files:
return []
# Filter out directories (only check files)
file_list = [f for f in files if not f.is_dir]
if not file_list:
return []
# Determine which strategy to use
use_accurate = self._should_use_accurate(len(file_list))
# Find duplicates
if use_accurate:
duplicates = self._find_by_hash(file_list)
else:
duplicates = self._find_by_fast_strategy(file_list)
# Sort by reclaimable space (descending)
duplicates.sort(key=lambda d: d.reclaimable_space, reverse=True)
return duplicates
def _should_use_accurate(self, file_count: int) -> bool:
"""
Determine whether to use accurate strategy.
Args:
file_count: Number of files to check.
Returns:
True if accurate strategy should be used.
"""
if self.strategy == "accurate":
return True
if self.strategy == "fast":
return False
# Adaptive: use accurate for small directories
return file_count < self.ADAPTIVE_THRESHOLD
def _find_by_hash(self, files: List[FileInfo]) -> List[DuplicateGroup]:
"""
Find duplicates using SHA-256 hash comparison.
This is the most accurate method but slower for large directories.
Args:
files: List of FileInfo objects.
Returns:
List of DuplicateGroup objects.
"""
# Group files by hash
hash_groups: Dict[str, List[FileInfo]] = {}
for file_info in files:
try:
# Calculate file hash
file_hash = self._calculate_hash(file_info.path)
if file_hash not in hash_groups:
hash_groups[file_hash] = []
hash_groups[file_hash].append(file_info)
except (OSError, IOError):
# Skip files we can't read
continue
# Create duplicate groups (only groups with 2+ files)
duplicates = []
for hash_value, file_list in hash_groups.items():
if len(file_list) > 1:
# All files in this group have the same size
size = file_list[0].size
duplicates.append(DuplicateGroup(files=file_list, size=size, hash_value=hash_value))
return duplicates
def _find_by_fast_strategy(self, files: List[FileInfo]) -> List[DuplicateGroup]:
"""
Find duplicates using fast size + mtime strategy.
Strategy:
1. Group by exact size (primary filter)
2. Within size groups, check mtime similarity
3. Hash verification only for likely duplicates
This is much faster for large directories but may miss some duplicates
or have false positives.
Args:
files: List of FileInfo objects.
Returns:
List of DuplicateGroup objects.
"""
# Step 1: Group by exact size
size_groups: Dict[int, List[FileInfo]] = {}
for file_info in files:
if file_info.size not in size_groups:
size_groups[file_info.size] = []
size_groups[file_info.size].append(file_info)
# Step 2: For each size group with 2+ files, check mtime similarity
potential_duplicates: List[Tuple[int, List[FileInfo]]] = []
for size, file_list in size_groups.items():
if len(file_list) < 2:
continue
# Check if files have similar mtimes (within threshold)
# Group by mtime buckets (1-second granularity)
mtime_groups: Dict[int, List[FileInfo]] = {}
for file_info in file_list:
mtime_bucket = int(file_info.mtime)
if mtime_bucket not in mtime_groups:
mtime_groups[mtime_bucket] = []
mtime_groups[mtime_bucket].append(file_info)
# Find files in same mtime bucket (likely duplicates)
for mtime_bucket, same_time_files in mtime_groups.items():
if len(same_time_files) >= 2:
potential_duplicates.append((size, same_time_files))
# Step 3: Hash verification for potential duplicates
# (to avoid false positives from fast strategy)
verified_duplicates: List[DuplicateGroup] = []
for size, file_list in potential_duplicates:
# Calculate hashes for these files
hash_groups: Dict[str, List[FileInfo]] = {}
for file_info in file_list:
try:
file_hash = self._calculate_hash(file_info.path)
if file_hash not in hash_groups:
hash_groups[file_hash] = []
hash_groups[file_hash].append(file_info)
except (OSError, IOError):
continue
# Add verified duplicate groups
for hash_value, same_hash_files in hash_groups.items():
if len(same_hash_files) >= 2:
verified_duplicates.append(
DuplicateGroup(files=same_hash_files, size=size, hash_value=hash_value)
)
return verified_duplicates
def _calculate_hash(self, file_path: str, chunk_size: int = 8192) -> str:
"""
Calculate SHA-256 hash of a file.
Args:
file_path: Path to file.
chunk_size: Read chunk size in bytes.
Returns:
Hexadecimal hash string.
"""
sha256_hash = hashlib.sha256()
with open(file_path, "rb") as f:
# Read file in chunks to handle large files
while chunk := f.read(chunk_size):
sha256_hash.update(chunk)
return sha256_hash.hexdigest()
def get_duplicate_stats(self, duplicates: List[DuplicateGroup]) -> Dict[str, int]:
"""
Calculate statistics about duplicate files.
Args:
duplicates: List of DuplicateGroup objects.
Returns:
Dictionary with statistics:
{
"group_count": number of duplicate groups,
"file_count": total duplicate files,
"total_size": total size of all duplicates,
"reclaimable": space that can be reclaimed
}
"""
if not duplicates:
return {
"group_count": 0,
"file_count": 0,
"total_size": 0,
"reclaimable": 0,
}
total_files = sum(d.count for d in duplicates)
total_size = sum(d.size * d.count for d in duplicates)
total_reclaimable = sum(d.reclaimable_space for d in duplicates)
return {
"group_count": len(duplicates),
"file_count": total_files,
"total_size": total_size,
"reclaimable": total_reclaimable,
}
diskcleaner/core/growth_analyzer.py
"""
Disk Growth Analyzer - Track and analyze disk space growth trends
This module provides functionality to:
1. Store historical disk usage data in JSON format
2. Calculate growth rates and trends
3. Predict future disk usage
4. Generate growth reports
Features:
- JSON-based persistent storage
- Cross-platform compatibility
- ASCII-safe output
- Trend analysis and prediction
"""
import json
import os
import platform
import sys
from datetime import datetime, timedelta
from pathlib import Path
from typing import Dict, List, Optional, Tuple
class GrowthAnalyzer:
"""
Analyze disk space growth trends over time.
Features:
- Store historical disk usage data
- Calculate growth rates (daily, weekly, monthly)
- Predict when disk will be full
- Identify unusual growth patterns
"""
def __init__(self, data_file: str = None):
"""
Initialize growth analyzer.
Args:
data_file: Path to JSON file for storing historical data.
If None, uses default location in user home directory.
"""
if data_file is None:
# Default: store in user's home directory
home_dir = Path.home()
data_dir = home_dir / ".diskcleaner"
data_dir.mkdir(exist_ok=True)
data_file = str(data_dir / "growth_history.json")
self.data_file = Path(data_file)
self.data_dir = self.data_file.parent
# Create data directory if it doesn't exist
self.data_dir.mkdir(parents=True, exist_ok=True)
# Load existing data
self.history = self._load_history()
def _load_history(self) -> Dict:
"""
Load historical data from JSON file.
Returns:
Dictionary with historical data
"""
if not self.data_file.exists():
return {"snapshots": []}
try:
with open(self.data_file, "r", encoding="utf-8") as f:
data = json.load(f)
# Validate data structure
if not isinstance(data, dict) or "snapshots" not in data:
print(f"[!] Invalid data file format, creating new one", file=sys.stderr)
return {"snapshots": []}
return data
except (json.JSONDecodeError, IOError) as e:
print(f"[!] Error loading history: {e}", file=sys.stderr)
return {"snapshots": []}
def _save_history(self) -> bool:
"""
Save historical data to JSON file.
Returns:
True if successful, False otherwise
"""
try:
# Create backup of existing file
if self.data_file.exists():
backup_file = self.data_file.with_suffix(".bak")
import shutil
shutil.copy2(self.data_file, backup_file)
# Save new data
with open(self.data_file, "w", encoding="utf-8") as f:
json.dump(self.history, f, indent=2)
return True
except (IOError, OSError) as e:
print(f"[!] Error saving history: {e}", file=sys.stderr)
return False
def add_snapshot(
self,
path: str,
used_bytes: int,
total_bytes: int,
free_bytes: int,
metadata: Dict = None,
) -> bool:
"""
Add a new disk usage snapshot.
Args:
path: Disk path or mount point
used_bytes: Used space in bytes
total_bytes: Total space in bytes
free_bytes: Free space in bytes
metadata: Optional metadata (e.g., scan time, file counts)
Returns:
True if snapshot was added successfully
"""
snapshot = {
"timestamp": datetime.now().isoformat(),
"path": path,
"used_bytes": used_bytes,
"total_bytes": total_bytes,
"free_bytes": free_bytes,
"used_percent": round((used_bytes / total_bytes * 100), 2) if total_bytes > 0 else 0,
"platform": platform.system(),
}
# Add optional metadata
if metadata:
snapshot["metadata"] = metadata
# Add to history
self.history["snapshots"].append(snapshot)
# Sort by timestamp
self.history["snapshots"].sort(key=lambda x: x["timestamp"])
# Limit history to last 1000 snapshots to prevent file from growing too large
if len(self.history["snapshots"]) > 1000:
self.history["snapshots"] = self.history["snapshots"][-1000:]
# Save to disk
return self._save_history()
def get_snapshots(
self,
path: str = None,
days: int = None,
limit: int = None,
) -> List[Dict]:
"""
Get snapshots from history.
Args:
path: Filter by path (if None, returns all)
days: Only return snapshots from last N days
limit: Maximum number of snapshots to return
Returns:
List of snapshot dictionaries
"""
snapshots = self.history["snapshots"]
# Filter by path
if path:
snapshots = [s for s in snapshots if s["path"] == path]
# Filter by time
if days:
cutoff_time = datetime.now() - timedelta(days=days)
snapshots = [
s for s in snapshots if datetime.fromisoformat(s["timestamp"]) >= cutoff_time
]
# Limit results
if limit:
snapshots = snapshots[-limit:]
return snapshots
def calculate_growth_rate(
self,
path: str = None,
period: str = "daily",
) -> Dict:
"""
Calculate growth rate for a specific period.
Args:
path: Disk path to analyze (if None, uses most common path)
period: Time period ('daily', 'weekly', 'monthly')
Returns:
Dictionary with growth rate statistics
"""
snapshots = self.get_snapshots(path=path, days=365) # Last year
if len(snapshots) < 2:
return {
"error": "Not enough data points (need at least 2 snapshots)",
"snapshots_count": len(snapshots),
}
# Use most common path if not specified
if path is None:
path_counts = {}
for s in snapshots:
path_counts[s["path"]] = path_counts.get(s["path"], 0) + 1
path = max(path_counts.keys(), key=lambda k: path_counts[k])
snapshots = [s for s in snapshots if s["path"] == path]
# Calculate time differences and growth
growth_data = []
for i in range(1, len(snapshots)):
current = snapshots[i]
previous = snapshots[i - 1]
current_time = datetime.fromisoformat(current["timestamp"])
previous_time = datetime.fromisoformat(previous["timestamp"])
time_diff = (current_time - previous_time).total_seconds() # seconds
used_diff = current["used_bytes"] - previous["used_bytes"]
if time_diff > 0:
# Growth rate in bytes per second
growth_rate = used_diff / time_diff
growth_data.append(
{
"timestamp": current["timestamp"],
"time_diff_seconds": time_diff,
"used_diff_bytes": used_diff,
"growth_rate_per_second": growth_rate,
}
)
if not growth_data:
return {
"error": "No growth data available",
"snapshots_count": len(snapshots),
}
# Calculate average growth rate for the period
avg_growth_per_second = sum(g["growth_rate_per_second"] for g in growth_data) / len(
growth_data
)
# Convert to requested period
seconds_per_period = {
"daily": 86400,
"weekly": 604800,
"monthly": 2592000, # 30 days
}
period_seconds = seconds_per_period.get(period, 86400)
avg_growth_per_period = avg_growth_per_second * period_seconds
# Calculate statistics
growth_rates = [g["growth_rate_per_second"] for g in growth_data]
# Find min/max growth rates
min_growth = min(growth_rates)
max_growth = max(growth_rates)
# Calculate trend (acceleration/deceleration)
if len(growth_data) >= 3:
recent_rate = growth_data[-1]["growth_rate_per_second"]
earlier_rate = growth_data[0]["growth_rate_per_second"]
acceleration = recent_rate - earlier_rate
else:
acceleration = 0
return {
"path": path,
"period": period,
"snapshots_analyzed": len(snapshots),
"growth_data_points": len(growth_data),
"avg_growth_bytes_per_period": round(avg_growth_per_period, 2),
"avg_growth_mb_per_period": round(avg_growth_per_period / (1024**2), 2),
"avg_growth_gb_per_period": round(avg_growth_per_period / (1024**3), 2),
"min_growth_bytes_per_period": round(min_growth * period_seconds, 2),
"max_growth_bytes_per_period": round(max_growth * period_seconds, 2),
"acceleration_bytes_per_second_sq": round(acceleration, 2),
"trend": (
"accelerating"
if acceleration > 0
else "decelerating" if acceleration < 0 else "stable"
),
}
def predict_full_date(self, path: str = None) -> Dict:
"""
Predict when the disk will be full based on growth rate.
Args:
path: Disk path to analyze
Returns:
Dictionary with prediction information
"""
snapshots = self.get_snapshots(path=path, days=365)
if len(snapshots) < 2:
return {
"error": "Not enough data for prediction (need at least 2 snapshots)",
}
# Get latest snapshot
latest = snapshots[-1]
# Calculate growth rate
growth_rate = self.calculate_growth_rate(path=path, period="daily")
if "error" in growth_rate:
return growth_rate
# Calculate days until full
free_bytes = latest["free_bytes"]
daily_growth = growth_rate["avg_growth_bytes_per_period"]
if daily_growth <= 0:
return {
"error": "No positive growth detected",
"current_usage_percent": latest["used_percent"],
"message": "Disk usage is stable or decreasing",
}
days_until_full = free_bytes / daily_growth
# Calculate full date
full_date = datetime.now() + timedelta(days=days_until_full)
return {
"path": latest["path"],
"current_used_bytes": latest["used_bytes"],
"current_free_bytes": latest["free_bytes"],
"current_total_bytes": latest["total_bytes"],
"current_usage_percent": latest["used_percent"],
"daily_growth_bytes": round(daily_growth, 2),
"daily_growth_mb": round(daily_growth / (1024**2), 2),
"daily_growth_gb": round(daily_growth / (1024**3), 2),
"days_until_full": round(days_until_full, 1),
"predicted_full_date": full_date.isoformat(),
"predicted_full_date_human": full_date.strftime("%Y-%m-%d"),
"weeks_until_full": round(days_until_full / 7, 1),
"months_until_full": round(days_until_full / 30, 1),
}
def generate_report(self, path: str = None) -> Dict:
"""
Generate comprehensive growth analysis report.
Args:
path: Disk path to analyze
Returns:
Dictionary with complete growth analysis
"""
snapshots = self.get_snapshots(path=path)
if not snapshots:
return {
"error": "No historical data available",
"message": "Run disk analysis multiple times over days/weeks to see trends",
}
# Use most recent snapshot path if not specified
if path is None:
latest = snapshots[-1]
path = latest["path"]
# Calculate growth rates for different periods
daily_rate = self.calculate_growth_rate(path=path, period="daily")
weekly_rate = self.calculate_growth_rate(path=path, period="weekly")
monthly_rate = self.calculate_growth_rate(path=path, period="monthly")
# Predict full date
prediction = self.predict_full_date(path=path)
# Compile report
report = {
"analysis_date": datetime.now().isoformat(),
"path": path,
"snapshots_count": len(snapshots),
"date_range": {
"earliest": snapshots[0]["timestamp"],
"latest": snapshots[-1]["timestamp"],
},
"growth_rates": {
"daily": daily_rate,
"weekly": weekly_rate,
"monthly": monthly_rate,
},
"prediction": prediction,
"latest_snapshot": snapshots[-1],
}
return report
def cleanup_old_data(self, days: int = 365) -> int:
"""
Remove snapshots older than specified days.
Args:
days: Keep only snapshots from last N days
Returns:
Number of snapshots removed
"""
cutoff_time = datetime.now() - timedelta(days=days)
original_count = len(self.history["snapshots"])
self.history["snapshots"] = [
s
for s in self.history["snapshots"]
if datetime.fromisoformat(s["timestamp"]) >= cutoff_time
]
removed_count = original_count - len(self.history["snapshots"])
if removed_count > 0:
self._save_history()
return removed_count
def format_size(bytes_size: int) -> str:
"""
Format byte size to human-readable string.
Args:
bytes_size: Size in bytes
Returns:
Formatted string (e.g., "1.5 GB", "500 MB")
"""
for unit in ["B", "KB", "MB", "GB", "TB"]:
if bytes_size < 1024.0:
return f"{bytes_size:.2f} {unit}"
bytes_size /= 1024.0
return f"{bytes_size:.2f} PB"
diskcleaner/core/interactive.py
"""
Interactive user interface for cleanup operations.
Provides menu-driven interaction for viewing and selecting files to clean.
"""
from datetime import datetime
from pathlib import Path
from typing import List, Optional, Set, Tuple
from diskcleaner.core.scanner import FileInfo
from diskcleaner.core.smart_cleanup import CleanupReport, SmartCleanupEngine
class InteractiveCleanupUI:
"""
Interactive interface for cleanup operations.
Features:
- View selection menu (type/risk/age/detailed)
- Hierarchical display with date ranges and average age
- File list detail view
- User selection logic
"""
def __init__(self, engine: SmartCleanupEngine):
"""
Initialize interactive UI.
Args:
engine: SmartCleanupEngine instance.
"""
self.engine = engine
self.selected_files: Set[str] = set()
def display_report_menu(self, report: CleanupReport) -> Optional[str]:
"""
Display main menu for report viewing.
Args:
report: CleanupReport to display.
Returns:
Selected view option, or None if exited.
"""
while True:
print("\n" + "=" * 60)
print("清理报告查看选项")
print("=" * 60)
print("1. 按类型查看")
print("2. 按风险等级查看")
print("3. 按时间查看")
print("4. 查看重复文件")
print("5. 详细列表")
print("6. 查看统计摘要")
print("0. 返回")
print("=" * 60)
choice = input("请选择 (0-6): ").strip()
if choice == "0":
return None
elif choice in ("1", "2", "3", "4", "5", "6"):
return choice
else:
print("无效选择，请重试")
def view_by_type(self, report: CleanupReport) -> List[str]:
"""
Display files grouped by type and allow selection.
Args:
report: CleanupReport to display.
Returns:
List of selected file paths.
"""
selected: Set[str] = set()
categories = sorted(
report.by_type.items(),
key=lambda x: sum(f.size for f in x[1]),
reverse=True,
)
while True:
print("\n" + "=" * 60)
print("按类型分类")
print("=" * 60)
for idx, (category, files) in enumerate(categories, 1):
if files:
total_size = sum(f.size for f in files)
selected_count = sum(1 for f in files if f.path in selected)
print(
f"{idx}. {category}: {len(files)} 文件, "
f"{self._format_size(total_size)} "
f"({selected_count}/{len(files)} 已选)"
)
print("\n操作:")
print(" 输入编号查看类别详情")
print(" a. 全选")
print(" c. 清除选择")
print(" s. 显示已选文件")
print(" 0. 返回")
choice = input("\n请选择: ").strip().lower()
if choice == "0":
break
elif choice == "a":
# Select all
for _, files in categories:
for f in files:
selected.add(f.path)
print(f"\n已选择 {len(selected)} 个文件")
elif choice == "c":
# Clear selection
selected.clear()
print("\n已清除所有选择")
elif choice == "s":
# Show selected files
self._display_selected_files(list(selected))
elif choice.isdigit() and 1 <= int(choice) <= len(categories):
# Show category details
idx = int(choice) - 1
category, files = categories[idx]
self._display_category_details(category, files, selected)
else:
print("无效选择")
return list(selected)
def view_by_risk(self, report: CleanupReport) -> List[str]:
"""
Display files grouped by risk level and allow selection.
Args:
report: CleanupReport to display.
Returns:
List of selected file paths.
"""
selected: Set[str] = set()
# Define risk level order and descriptions
risk_levels = [
("safe", "安全删除", report.by_risk.get("safe", [])),
(
"confirm_needed",
"需要确认",
report.by_risk.get("confirm_needed", []),
),
(
"protected",
"受保护",
report.by_risk.get("protected", []),
),
]
while True:
print("\n" + "=" * 60)
print("按风险等级分类")
print("=" * 60)
for idx, (key, label, files) in enumerate(risk_levels, 1):
if files:
total_size = sum(f.size for f in files)
selected_count = sum(1 for f in files if f.path in selected)
print(
f"{idx}. {label}: {len(files)} 文件, "
f"{self._format_size(total_size)} "
f"({selected_count}/{len(files)} 已选)"
)
print("\n操作:")
print(" 输入编号查看类别详情")
print(" a. 全选安全文件")
print(" c. 清除选择")
print(" s. 显示已选文件")
print(" 0. 返回")
choice = input("\n请选择: ").strip().lower()
if choice == "0":
break
elif choice == "a":
# Select all safe files
for f in report.by_risk.get("safe", []):
selected.add(f.path)
print(f"\n已选择 {len(selected)} 个文件")
elif choice == "c":
selected.clear()
print("\n已清除所有选择")
elif choice == "s":
self._display_selected_files(list(selected))
elif choice.isdigit() and 1 <= int(choice) <= len(risk_levels):
idx = int(choice) - 1
key, label, files = risk_levels[idx]
if files:
self._display_category_details(label, files, selected)
else:
print("无效选择")
return list(selected)
def view_by_age(self, report: CleanupReport) -> List[str]:
"""
Display files grouped by age and allow selection.
Args:
report: CleanupReport to display.
Returns:
List of selected file paths.
"""
selected: Set[str] = set()
age_groups = sorted(
report.by_age.items(),
key=lambda x: self._get_age_order(x[0]),
)
while True:
print("\n" + "=" * 60)
print("按时间分类")
print("=" * 60)
for idx, (age_group, files) in enumerate(age_groups, 1):
if files:
total_size = sum(f.size for f in files)
avg_age = self._calculate_average_age(files)
selected_count = sum(1 for f in files if f.path in selected)
print(
f"{idx}. {age_group}: {len(files)} 文件, "
f"{self._format_size(total_size)}, "
f"平均年龄 {avg_age:.0f} 天 "
f"({selected_count}/{len(files)} 已选)"
)
print("\n操作:")
print(" 输入编号查看类别详情")
print(" a. 全选陈旧文件(>30天)")
print(" c. 清除选择")
print(" s. 显示已选文件")
print(" 0. 返回")
choice = input("\n请选择: ").strip().lower()
if choice == "0":
break
elif choice == "a":
# Select old files (> 30 days)
for age_group, files in age_groups:
if "30天以上" in age_group or "90" in age_group:
for f in files:
selected.add(f.path)
print(f"\n已选择 {len(selected)} 个文件")
elif choice == "c":
selected.clear()
print("\n已清除所有选择")
elif choice == "s":
self._display_selected_files(list(selected))
elif choice.isdigit() and 1 <= int(choice) <= len(age_groups):
idx = int(choice) - 1
age_group, files = age_groups[idx]
if files:
self._display_category_details(age_group, files, selected)
else:
print("无效选择")
return list(selected)
def view_duplicates(self, report: CleanupReport) -> List[Tuple[str, int]]:
"""
Display duplicate file groups and allow selection.
Args:
report: CleanupReport to display.
Returns:
List of (file_path, group_index) tuples for selected duplicates.
"""
selected: Set[Tuple[str, int]] = set()
if not report.duplicates:
print("\n未发现重复文件")
return []
while True:
print("\n" + "=" * 60)
print("重复文件组")
print("=" * 60)
for idx, dup_group in enumerate(report.duplicates[:20], 1): # Show first 20
selected_in_group = sum(1 for f in dup_group.files if (f.path, idx) in selected)
print(
f"{idx}. {dup_group.count} 个重复文件, "
f"{self._format_size(dup_group.size)} 每个, "
f"可回收 {self._format_size(dup_group.reclaimable_space)} "
f"({selected_in_group}/{dup_group.count} 已选)"
)
if len(report.duplicates) > 20:
print(f"\n... 还有 {len(report.duplicates) - 20} 组重复文件")
print("\n操作:")
print(" 输入编号查看组详情")
print(" a. 全选重复文件(每组保留1个)")
print(" c. 清除选择")
print(" s. 显示已选文件")
print(" 0. 返回")
choice = input("\n请选择: ").strip().lower()
if choice == "0":
break
elif choice == "a":
# Select all duplicates (keeping 1 per group)
for idx, dup_group in enumerate(report.duplicates, 1):
# Select all but the first file in each group
for file in dup_group.files[1:]:
selected.add((file.path, idx))
print(f"\n已选择 {len(selected)} 个重复文件")
elif choice == "c":
selected.clear()
print("\n已清除所有选择")
elif choice == "s":
self._display_selected_duplicates(
[(path, idx) for path, idx in selected], report.duplicates
)
elif choice.isdigit() and 1 <= int(choice) <= min(len(report.duplicates), 20):
idx = int(choice)
dup_group = report.duplicates[idx - 1]
self._display_duplicate_group_details(idx, dup_group, selected)
else:
print("无效选择")
return [(path, idx) for path, idx in selected]
def view_detailed_list(self, report: CleanupReport) -> List[str]:
"""
Display detailed list of all files with pagination.
Args:
report: CleanupReport to display.
Returns:
List of selected file paths.
"""
selected: Set[str] = set()
all_files = []
for files in report.by_type.values():
all_files.extend(files)
# Sort by size (descending)
all_files.sort(key=lambda f: f.size, reverse=True)
page_size = 20
current_page = 0
total_pages = (len(all_files) + page_size - 1) // page_size
while True:
print("\n" + "=" * 60)
print(f"详细文件列表 (第 {current_page + 1}/{total_pages} 页)")
print("=" * 60)
start = current_page * page_size
end = min(start + page_size, len(all_files))
page_files = all_files[start:end]
print(f"{'序号':<6} {'文件名':<30} {'大小':>12} {'修改时间':<20} {'状态':<6}")
print("-" * 80)
for i, file in enumerate(page_files, start + 1):
status = "✓" if file.path in selected else " "
mtime_str = datetime.fromtimestamp(file.mtime).strftime("%Y-%m-%d %H:%M")
print(
f"{i:<6} {file.name[:30]:<30} "
f"{self._format_size(file.size):>12} "
f"{mtime_str:<20} "
f"[{status}]"
)
print("\n操作:")
print(" 输入编号选择/取消选择文件")
print(" n. 下一页")
print(" p. 上一页")
print(" a. 全选当前页")
print(" c. 清除所有选择")
print(" s. 显示已选文件")
print(" 0. 返回")
choice = input(f"\n请选择 (第{current_page + 1}页): ").strip().lower()
if choice == "0":
break
elif choice == "n" and current_page < total_pages - 1:
current_page += 1
elif choice == "p" and current_page > 0:
current_page -= 1
elif choice == "a":
# Select all on current page
for file in page_files:
selected.add(file.path)
print(f"已选择当前页 {len(page_files)} 个文件")
elif choice == "c":
selected.clear()
print("\n已清除所有选择")
elif choice == "s":
self._display_selected_files(list(selected))
elif choice.isdigit():
# Toggle file selection
idx = int(choice) - 1
if 0 <= idx < len(all_files):
file = all_files[idx]
if file.path in selected:
selected.remove(file.path)
else:
selected.add(file.path)
else:
print("无效选择")
return list(selected)
def _display_category_details(
self, category: str, files: List[FileInfo], selected: Set[str]
) -> None:
"""Display details of files in a category."""
print(f"\n{category} - 文件列表")
print("-" * 80)
for i, file in enumerate(files[:20], 1): # Show first 20
status = "✓" if file.path in selected else " "
mtime_str = datetime.fromtimestamp(file.mtime).strftime("%Y-%m-%d %H:%M")
print(
f"{i:3}. [{status}] {file.name:<40} "
f"{self._format_size(file.size):>12} "
f"{mtime_str}"
)
if len(files) > 20:
print(f"\n... 还有 {len(files) - 20} 个文件")
print("\n操作: 输入编号选择/取消选择，或 0 返回")
choice = input("请选择: ").strip()
if choice.isdigit() and 1 <= int(choice) <= min(len(files), 20):
idx = int(choice) - 1
file = files[idx]
if file.path in selected:
selected.remove(file.path)
print(f"\n已取消选择: {file.name}")
else:
selected.add(file.path)
print(f"\n已选择: {file.name}")
def _display_duplicate_group_details(
self, group_idx: int, dup_group, selected: Set[Tuple[str, int]]
) -> None:
"""Display details of duplicate files in a group."""
print(f"\n重复文件组 #{group_idx}")
print(f"文件大小: {self._format_size(dup_group.size)}")
print(f"哈希值: {dup_group.hash_value[:16]}...")
print("-" * 80)
for i, file in enumerate(dup_group.files, 1):
status = "✓" if (file.path, group_idx) in selected else " "
print(f"{i}. [{status}] {file.path}")
print("\n操作: 输入编号选择/取消选择文件，或 0 返回")
choice = input("请选择: ").strip()
if choice.isdigit() and 1 <= int(choice) <= len(dup_group.files):
idx = int(choice) - 1
file = dup_group.files[idx]
if (file.path, group_idx) in selected:
selected.remove((file.path, group_idx))
print(f"\n已取消选择: {file.path}")
else:
selected.add((file.path, group_idx))
print(f"\n已选择: {file.path}")
def _display_selected_files(self, selected_paths: List[str]) -> None:
"""Display list of selected files."""
if not selected_paths:
print("\n未选择任何文件")
return
print(f"\n已选择的文件 ({len(selected_paths)} 个):")
print("-" * 80)
total_size = 0
for i, path in enumerate(selected_paths[:20], 1):
file = Path(path)
print(f"{i:3}. {path}")
if file.exists():
total_size += file.stat().st_size
if len(selected_paths) > 20:
print(f"\n... 还有 {len(selected_paths) - 20} 个文件")
print(f"\n总计: {len(selected_paths)} 个文件, {self._format_size(total_size)}")
def _display_selected_duplicates(
self, selected: List[Tuple[str, int]], duplicates: list
) -> None:
"""Display list of selected duplicate files."""
if not selected:
print("\n未选择任何重复文件")
return
print(f"\n已选择的重复文件 ({len(selected)} 个):")
print("-" * 80)
for path, group_idx in selected[:20]:
print(f"组 #{group_idx}: {path}")
if len(selected) > 20:
print(f"\n... 还有 {len(selected) - 20} 个文件")
def _calculate_average_age(self, files: List[FileInfo]) -> float:
"""Calculate average age of files in days."""
if not files:
return 0.0
now = datetime.now()
total_age = sum((now - datetime.fromtimestamp(f.mtime)).days for f in files)
return total_age / len(files)
def _get_age_order(self, age_group: str) -> int:
"""Get sort order for age groups."""
if "7天" in age_group:
return 1
elif "30天" in age_group:
return 2
elif "90天" in age_group:
return 3
else:
return 4
def _format_size(self, size_bytes: int) -> str:
"""Format byte size to human-readable string."""
for unit in ["B", "KB", "MB", "GB", "TB"]:
if size_bytes < 1024.0:
if unit == "B":
return f"{size_bytes:,} {unit}"
return f"{size_bytes:.2f} {unit}"
size_bytes /= 1024.0
return f"{size_bytes:.2f} PB"
def confirm_and_cleanup(
self,
files_to_delete: List[str],
dry_run: bool = True,
backup: bool = True,
) -> bool:
"""
Display cleanup summary and request final confirmation.
Args:
files_to_delete: List of file paths to delete.
dry_run: If True, only show what would be deleted.
backup: If True, create backups before deleting.
Returns:
True if cleanup was performed, False if cancelled.
"""
if not files_to_delete:
print("\n未选择要删除的文件")
return False
# Calculate statistics
total_size = 0
valid_files = []
for file_path in files_to_delete:
path = Path(file_path)
if path.exists():
try:
total_size += path.stat().st_size
valid_files.append(file_path)
except OSError:
pass
if not valid_files:
print("\n选定的文件不存在或无法访问")
return False
# Display cleanup summary
self._display_cleanup_summary(valid_files, total_size, dry_run)
# Request final confirmation
if dry_run:
print("\n[预览模式] 不会实际删除文件")
print("如要执行删除，请重新运行时不使用 --dry-run 参数")
return False
confirmation = input("\n确认删除以上文件？(输入 YES 继续): ").strip()
if confirmation != "YES":
print("\n操作已取消")
return False
# Perform cleanup
print("\n开始清理...")
success = self._execute_cleanup(valid_files, backup)
if success:
print("\n✓ 清理完成！")
print(" 删除文件数: {}".format(len(valid_files)))
print(" 释放空间: {}".format(self._format_size(total_size)))
return True
else:
print("\n✗ 清理过程中出现错误")
return False
def _display_cleanup_summary(self, files: List[str], total_size: int, dry_run: bool) -> None:
"""Display cleanup summary before confirmation."""
print("\n" + "=" * 60)
print("清理摘要")
print("=" * 60)
print("将删除 {} 个文件".format(len(files)))
print("释放空间: {}".format(self._format_size(total_size)))
print("模式: {}".format("预览 (不会实际删除)" if dry_run else "执行删除"))
print("=" * 60)
# Show first 20 files
print("\n文件列表:")
for i, file_path in enumerate(files[:20], 1):
path = Path(file_path)
size = path.stat().st_size if path.exists() else 0
print(f"{i:3}. {file_path} ({self._format_size(size)})")
if len(files) > 20:
print(f"\n... 还有 {len(files) - 20} 个文件")
print("\n" + "=" * 60)
def _execute_cleanup(self, files: List[str], backup: bool) -> bool:
"""
Execute cleanup operation.
Args:
files: List of file paths to delete.
backup: If True, create backups before deleting.
Returns:
True if all files were processed successfully.
"""
from diskcleaner.core.safety import SafetyChecker
safety_checker = SafetyChecker()
success_count = 0
failed_files = []
for file_path in files:
try:
path = Path(file_path)
# Create backup if requested
if backup:
backup_path = safety_checker.backup_file(file_path)
if backup_path:
pass # Backup created successfully
# Delete file
if path.is_file():
path.unlink()
elif path.is_dir():
path.rmdir()
success_count += 1
# Log deletion
self._log_deletion(file_path)
except OSError as e:
failed_files.append((file_path, str(e)))
# Report results
if failed_files:
print(f"\n警告: {len(failed_files)} 个文件删除失败:")
for file_path, error in failed_files[:10]:
print(f" {file_path}: {error}")
if len(failed_files) > 10:
print(f" ... 还有 {len(failed_files) - 10} 个失败")
return len(failed_files) == 0
def _log_deletion(self, file_path: str) -> None:
"""Log file deletion to cleanup log."""
log_dir = Path.home() / ".disk-cleaner" / "logs"
log_dir.mkdir(parents=True, exist_ok=True)
log_file = log_dir / "cleanup.log"
timestamp = datetime.now().isoformat()
log_entry = f"{timestamp} | DELETED | {file_path}\n"
try:
with open(log_file, "a", encoding="utf-8") as f:
f.write(log_entry)
except OSError:
pass # Silently fail if can't write log
diskcleaner/core/organizer.py
"""
File organizer with plan generation and execution.
Integrates scanner, classifier, and archive rules to
organize files intelligently with dry-run support.
"""
import os
import shutil
from dataclasses import dataclass, field
from datetime import datetime
from pathlib import Path
from typing import Callable, Dict, List, Optional, Tuple
from diskcleaner.config import Config
from diskcleaner.core.classifier import FileClassifier
from diskcleaner.core.rules.archive_rules import RuleEngine
from diskcleaner.core.safety import SafetyChecker
from diskcleaner.core.scanner import DirectoryScanner, FileInfo
@dataclass
class OrganizationAction:
"""
A single file organization action.
Attributes:
source_path: Source file path.
destination_path: Destination file path.
action_type: Type of action (move, copy, skip).
reason: Reason for action (e.g., rule name, skip reason).
file_info: FileInfo object for the file.
"""
source_path: str
destination_path: str
action_type: str # "move", "copy", "skip"
reason: str
file_info: FileInfo
def __str__(self) -> str:
"""String representation for ASCII safety."""
return f"{self.action_type.upper()}: {self.source_path} -> {self.destination_path}"
@dataclass
class OrganizationPlan:
"""
Complete organization plan.
Attributes:
target_path: Base path being organized.
strategy: Strategy name used.
actions: List of actions to perform.
total_size: Total size of files to organize.
file_count: Number of files to organize.
created_at: Timestamp when plan was created.
"""
target_path: str
strategy: str
actions: List[OrganizationAction] = field(default_factory=list)
total_size: int = 0
file_count: int = 0
created_at: float = field(default_factory=datetime.now().timestamp)
def add_action(self, action: OrganizationAction):
"""
Add an action to the plan.
Args:
action: OrganizationAction to add.
"""
self.actions.append(action)
self.file_count += 1
self.total_size += action.file_info.size
def get_summary(self) -> Dict[str, int]:
"""
Get summary statistics.
Returns:
Dictionary with action counts and sizes.
"""
summary = {
"total_actions": len(self.actions),
"move_actions": 0,
"copy_actions": 0,
"skip_actions": 0,
"total_size": self.total_size,
"file_count": self.file_count,
}
for action in self.actions:
if action.action_type == "move":
summary["move_actions"] += 1
elif action.action_type == "copy":
summary["copy_actions"] += 1
elif action.action_type == "skip":
summary["skip_actions"] += 1
return summary
def get_actions_by_destination(self) -> Dict[str, List[OrganizationAction]]:
"""
Group actions by destination.
Returns:
Dictionary mapping destinations to action lists.
"""
grouped: Dict[str, List[OrganizationAction]] = {}
for action in self.actions:
if action.destination_path not in grouped:
grouped[action.destination_path] = []
grouped[action.destination_path].append(action)
return grouped
class FileOrganizer:
"""
File organizer with plan generation and execution.
Features:
- Multiple organization strategies
- Dry-run mode for preview
- Safety checks before operations
- Progress tracking
- Conflict detection
"""
def __init__(
self,
target_path: str,
strategy: str = "desktop",
config: Optional[Config] = None,
dry_run: bool = True,
):
"""
Initialize file organizer.
Args:
target_path: Path to organize.
strategy: Organization strategy name.
config: Configuration object.
dry_run: If True, don't actually move files (preview mode).
"""
self.target_path = Path(target_path).expanduser().resolve()
self.strategy_name = strategy
self.config = config or Config.load()
self.dry_run = dry_run
# Initialize components
self.scanner = DirectoryScanner(str(self.target_path), config=self.config)
self.classifier = FileClassifier(config=self.config)
self.safety_checker = SafetyChecker(config=self.config)
self.rule_engine = RuleEngine()
# Validate strategy
if not self.rule_engine.get_strategy(strategy):
raise ValueError(f"Unknown strategy: {strategy}")
# Statistics
self.organized_count = 0
self.skipped_count = 0
self.error_count = 0
def scan_files(self) -> List[FileInfo]:
"""
Scan target directory for files.
Returns:
List of FileInfo objects.
"""
return self.scanner.scan()
def generate_plan(
self,
files: Optional[List[FileInfo]] = None,
progress_callback: Optional[Callable[[int, int], None]] = None,
) -> OrganizationPlan:
"""
Generate organization plan.
Args:
files: List of FileInfo objects (scans if None).
progress_callback: Optional callback for progress updates.
Returns:
OrganizationPlan with actions to perform.
"""
# Scan files if not provided
if files is None:
files = self.scan_files()
plan = OrganizationPlan(
target_path=str(self.target_path),
strategy=self.strategy_name,
)
# Get strategy
strategy = self.rule_engine.get_strategy(self.strategy_name)
if not strategy:
raise ValueError(f"Unknown strategy: {self.strategy_name}")
# Process each file
total_files = len(files)
for i, file in enumerate(files):
# Skip directories
if file.is_dir:
continue
# Update progress
if progress_callback:
progress_callback(i + 1, total_files)
# Get destination from strategy
destination = strategy.organize_file(file)
if destination is None:
# No rule matched - skip
action = OrganizationAction(
source_path=file.path,
destination_path="",
action_type="skip",
reason="No matching rule",
file_info=file,
)
plan.add_action(action)
continue
# Build full destination path
dest_path = self.target_path / destination
# Check for conflicts
conflict_reason = self._check_conflicts(file, dest_path)
if conflict_reason:
action = OrganizationAction(
source_path=file.path,
destination_path=str(dest_path),
action_type="skip",
reason=f"Conflict: {conflict_reason}",
file_info=file,
)
plan.add_action(action)
continue
# Safety check
safety_status = self.safety_checker.verify_file(file)
if safety_status.value != "safe":
action = OrganizationAction(
source_path=file.path,
destination_path=str(dest_path),
action_type="skip",
reason=f"Safety check: {safety_status.value}",
file_info=file,
)
plan.add_action(action)
continue
# Create move action
dest_file_path = dest_path / file.name
action = OrganizationAction(
source_path=file.path,
destination_path=str(dest_file_path),
action_type="move",
reason=f"Rule: {destination}",
file_info=file,
)
plan.add_action(action)
return plan
def _check_conflicts(self, file: FileInfo, dest_path: Path) -> Optional[str]:
"""
Check for file conflicts at destination.
Args:
file: FileInfo object.
dest_path: Destination directory path.
Returns:
Conflict reason string, or None if no conflict.
"""
dest_file_path = dest_path / file.name
# Check if destination file exists
if dest_file_path.exists():
# Check if it's the same file
if str(dest_file_path) == file.path:
return "Source and destination are the same"
# Check if files are identical
if dest_file_path.stat().st_size == file.size:
return "Duplicate file (same size)"
return "File with same name exists"
return None
def execute_plan(
self,
plan: OrganizationPlan,
progress_callback: Optional[Callable[[int, int], None]] = None,
) -> Tuple[int, int, int]:
"""
Execute organization plan.
Args:
plan: OrganizationPlan to execute.
progress_callback: Optional callback for progress updates.
Returns:
Tuple of (organized_count, skipped_count, error_count).
"""
organized = 0
skipped = 0
errors = 0
total_actions = len(plan.actions)
for i, action in enumerate(plan.actions):
# Update progress
if progress_callback:
progress_callback(i + 1, total_actions)
if action.action_type == "skip":
skipped += 1
continue
if action.action_type == "move":
try:
if not self.dry_run:
self._move_file(action)
organized += 1
except Exception as e:
errors += 1
# Log error but continue
print(f"Error moving {action.source_path}: {e}")
elif action.action_type == "copy":
try:
if not self.dry_run:
self._copy_file(action)
organized += 1
except Exception as e:
errors += 1
print(f"Error copying {action.source_path}: {e}")
return organized, skipped, errors
def _move_file(self, action: OrganizationAction):
"""
Move a file to its destination.
Args:
action: OrganizationAction with move operation.
"""
source = Path(action.source_path)
destination = Path(action.destination_path)
# Create destination directory
destination.parent.mkdir(parents=True, exist_ok=True)
# Handle duplicates
if destination.exists():
# Add timestamp to filename
stem = source.stem
suffix = source.suffix
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
new_name = f"{stem}_{timestamp}{suffix}"
destination = destination.parent / new_name
# Move file
shutil.move(str(source), str(destination))
def _copy_file(self, action: OrganizationAction):
"""
Copy a file to its destination.
Args:
action: OrganizationAction with copy operation.
"""
source = Path(action.source_path)
destination = Path(action.destination_path)
# Create destination directory
destination.parent.mkdir(parents=True, exist_ok=True)
# Handle duplicates
if destination.exists():
# Add timestamp to filename
stem = source.stem
suffix = source.suffix
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
new_name = f"{stem}_{timestamp}{suffix}"
destination = destination.parent / new_name
# Copy file
shutil.copy2(str(source), str(destination))
def preview_organization(
self,
max_files: int = 50,
) -> str:
"""
Preview organization plan (ASCII-safe output).
Args:
max_files: Maximum number of files to show in preview.
Returns:
Formatted preview string.
"""
# Generate plan
plan = self.generate_plan()
# Build preview
lines = []
lines.append("=" * 80)
lines.append(f"FILE ORGANIZATION PREVIEW")
lines.append(f"Strategy: {self.strategy_name}")
lines.append(f"Target: {self.target_path}")
lines.append(f"Mode: {'DRY RUN (no changes)' if self.dry_run else 'EXECUTE'}")
lines.append("=" * 80)
lines.append("")
# Show summary
summary = plan.get_summary()
lines.append("SUMMARY:")
lines.append(f" Total files to process: {summary['file_count']}")
lines.append(f" Files to organize: {summary['move_actions'] + summary['copy_actions']}")
lines.append(f" Files to skip: {summary['skip_actions']}")
lines.append(f" Total size: {self._format_size(summary['total_size'])}")
lines.append("")
# Show actions by destination
grouped = plan.get_actions_by_destination()
lines.append("DESTINATIONS:")
for dest, actions in sorted(grouped.items()):
if dest: # Skip empty destinations
dest_size = sum(a.file_info.size for a in actions)
lines.append(f" {dest}: {len(actions)} files ({self._format_size(dest_size)})")
lines.append("")
# Show sample actions
lines.append(f"SAMPLE ACTIONS (showing first {min(max_files, len(plan.actions))}):")
for i, action in enumerate(plan.actions[:max_files]):
lines.append(f" [{i+1}] {action}")
if len(plan.actions) > max_files:
remaining = len(plan.actions) - max_files
lines.append(f" ... and {remaining} more actions")
lines.append("")
lines.append("=" * 80)
return "\n".join(lines)
def _format_size(self, size_bytes: int) -> str:
"""
Format size in human-readable format.
Args:
size_bytes: Size in bytes.
Returns:
Formatted size string.
"""
for unit in ["B", "KB", "MB", "GB", "TB"]:
if size_bytes < 1024.0:
return f"{size_bytes:.1f} {unit}"
size_bytes /= 1024.0
return f"{size_bytes:.1f} PB"
def organize(
self,
progress_callback: Optional[Callable[[int, int], None]] = None,
) -> Tuple[int, int, int]:
"""
Organize files (generate and execute plan).
Args:
progress_callback: Optional callback for progress updates.
Returns:
Tuple of (organized_count, skipped_count, error_count).
"""
# Generate plan
plan = self.generate_plan(progress_callback=progress_callback)
# Execute plan
organized, skipped, errors = self.execute_plan(
plan,
progress_callback=progress_callback,
)
# Update statistics
self.organized_count = organized
self.skipped_count = skipped
self.error_count = errors
return organized, skipped, errors
def get_statistics(self) -> Dict[str, int]:
"""
Get organization statistics.
Returns:
Dictionary with statistics.
"""
return {
"organized": self.organized_count,
"skipped": self.skipped_count,
"errors": self.error_count,
}
diskcleaner/core/process_manager.py
"""
Process manager for handling locked files.
Provides cross-platform process detection and termination capabilities
with interactive user interface.
"""
import os
import platform
import subprocess
from dataclasses import dataclass
from typing import List, Optional, Tuple
from diskcleaner.core.scanner import FileInfo
@dataclass
class ProcessInfo:
"""Information about a process."""
pid: int
name: str
cmdline: Optional[str] = None
username: Optional[str] = None
cpu_percent: Optional[float] = None
memory_mb: Optional[float] = None
def __str__(self) -> str:
"""Return string representation."""
if self.cmdline:
cmdline_short = self.cmdline[:50] + "..." if len(self.cmdline) > 50 else self.cmdline
return "Process {} (PID: {}, CMD: {})".format(self.name, self.pid, cmdline_short)
return "Process {} (PID: {})".format(self.name, self.pid)
class ProcessManager:
"""
Cross-platform process manager for handling locked files.
Features:
- Detect processes locking files
- Display detailed process information
- Terminate processes with confirmation
- Support for Windows, Linux, macOS
"""
def __init__(self):
"""Initialize process manager."""
self.platform = platform.system()
def get_locking_processes(self, file_path: str) -> List[ProcessInfo]:
"""
Get all processes that are locking a file.
Args:
file_path: Path to the file.
Returns:
List of ProcessInfo objects.
"""
if self.platform == "Windows":
return self._get_locking_processes_windows(file_path)
elif self.platform in ["Linux", "Darwin"]:
return self._get_locking_processes_unix(file_path)
else:
return []
def _get_locking_processes_windows(self, file_path: str) -> List[ProcessInfo]:
"""
Get processes locking a file on Windows.
Uses handle.exe from Sysinternals or tasklist as fallback.
Args:
file_path: Path to the file.
Returns:
List of ProcessInfo objects.
"""
processes = []
# Try using handle.exe first (more reliable)
try:
result = subprocess.run(
["handle.exe", file_path],
capture_output=True,
text=True,
timeout=30,
)
# Parse handle.exe output
lines = result.stdout.split("\n")
for line in lines:
if file_path.lower() in line.lower():
# Extract PID and process name
# Typical format: "chrome.exe pid: 12345 type: File"
parts = line.split()
if len(parts) >= 3 and "pid:" in parts[2]:
name = parts[0]
pid_str = parts[2].replace("pid:", "").strip()
try:
pid = int(pid_str)
processes.append(ProcessInfo(pid=pid, name=name))
except ValueError:
continue
except (FileNotFoundError, subprocess.TimeoutExpired):
# Fallback to tasklist/openfiles method
try:
# Use openfiles command (Windows 7+)
result = subprocess.run(
["openfiles", "/query", "/v", file_path],
capture_output=True,
text=True,
timeout=30,
)
lines = result.stdout.split("\n")
for line in lines:
if file_path.lower() in line.lower():
# Parse and extract PID
parts = line.split()
for i, part in enumerate(parts):
if part.lower() == "pid:" and i + 1 < len(parts):
try:
pid = int(parts[i + 1].rstrip(","))
# Try to get process name
name = self._get_process_name_windows(pid)
processes.append(ProcessInfo(pid=pid, name=name))
except ValueError:
continue
except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
pass
return processes
def _get_locking_processes_unix(self, file_path: str) -> List[ProcessInfo]:
"""
Get processes locking a file on Unix-like systems.
Uses lsof command.
Args:
file_path: Path to the file.
Returns:
List of ProcessInfo objects.
"""
processes = []
try:
result = subprocess.run(
["lsof", "-t", file_path],
capture_output=True,
text=True,
timeout=10,
)
# lsof -t returns list of PIDs
pid_strings = result.stdout.strip().split("\n")
for pid_str in pid_strings:
if not pid_str:
continue
try:
pid = int(pid_str)
# Get process details
proc_info = self._get_process_details_unix(pid)
if proc_info:
processes.append(proc_info)
except ValueError:
continue
except (FileNotFoundError, subprocess.TimeoutExpired):
pass
return processes
def _get_process_name_windows(self, pid: int) -> str:
"""Get process name on Windows."""
try:
result = subprocess.run(
["tasklist", "/FI", f"PID eq {pid}", "/FO", "CSV", "/NH"],
capture_output=True,
text=True,
timeout=5,
)
# Parse CSV output
line = result.stdout.strip()
if line and '","' in line:
# Format: "chrome.exe","12345","Console","1","150,000 K"
parts = line.split('","')
if parts:
name = parts[0].strip('"')
return name
except (FileNotFoundError, subprocess.TimeoutExpired):
pass
return "Unknown"
def _get_process_details_unix(self, pid: int) -> Optional[ProcessInfo]:
"""Get detailed process info on Unix."""
try:
# Get process name and command
result = subprocess.run(
["ps", "-p", str(pid), "-o", "comm,cmd,user,%cpu,rss"],
capture_output=True,
text=True,
timeout=5,
)
lines = result.stdout.strip().split("\n")
if len(lines) < 2:
return None
# Skip header
parts = lines[1].split(None, 4)
if len(parts) < 5:
return None
name = parts[0]
cmdline = parts[1] if len(parts) > 1 else None
username = parts[2] if len(parts) > 2 else None
try:
cpu_percent = float(parts[3]) if len(parts) > 3 else None
except ValueError:
cpu_percent = None
try:
# RSS is in KB, convert to MB
memory_kb = int(parts[4]) if len(parts) > 4 else 0
memory_mb = memory_kb / 1024.0
except ValueError:
memory_mb = None
return ProcessInfo(
pid=pid,
name=name,
cmdline=cmdline,
username=username,
cpu_percent=cpu_percent,
memory_mb=memory_mb,
)
except (FileNotFoundError, subprocess.TimeoutExpired):
return None
def terminate_process(self, process: ProcessInfo, timeout: int = 10) -> bool:
"""
Terminate a process.
Args:
process: ProcessInfo object.
timeout: Timeout in seconds.
Returns:
True if successful, False otherwise.
"""
try:
if self.platform == "Windows":
subprocess.run(
["taskkill", "/F", "/PID", str(process.pid)],
check=True,
timeout=timeout,
capture_output=True,
)
else:
subprocess.run(
["kill", "-9", str(process.pid)],
check=True,
timeout=timeout,
capture_output=True,
)
return True
except (subprocess.CalledProcessError, subprocess.TimeoutExpired):
return False
def get_process_details(self, process: ProcessInfo) -> str:
"""
Get detailed information about a process.
Args:
process: ProcessInfo object.
Returns:
Formatted string with process details.
"""
lines = [
"=" * 60,
"进程详细信息",
"=" * 60,
"PID: {}".format(process.pid),
"名称: {}".format(process.name),
]
if process.username:
lines.append("用户: {}".format(process.username))
if process.cmdline:
lines.append("命令: {}".format(process.cmdline))
if process.cpu_percent is not None:
lines.append("CPU: {:.1f}%".format(process.cpu_percent))
if process.memory_mb is not None:
lines.append("内存: {:.1f} MB".format(process.memory_mb))
lines.append("=" * 60)
return "\n".join(lines)
def can_terminate_process(self, process: ProcessInfo) -> Tuple[bool, str]:
"""
Check if a process can be terminated safely.
Args:
process: ProcessInfo object.
Returns:
Tuple of (can_terminate, reason).
"""
# Check if process is critical system process
critical_processes = {
"windows": [
"system",
"smss.exe",
"csrss.exe",
"wininit.exe",
"winlogon.exe",
"services.exe",
"lsass.exe",
"svchost.exe",
],
"linux": ["init", "kthreadd", "systemd", "ksoftirqd"],
"darwin": ["launchd", "kernel_task"],
}
platform_key = self.platform.lower()
if platform_key == "darwin":
platform_key = "linux"
if platform_key in critical_processes:
name_lower = process.name.lower()
for critical in critical_processes[platform_key]:
if critical in name_lower or name_lower in critical:
return False, "关键系统进程，不应终止"
# Check if we have permissions
if process.username:
import getpass
current_user = getpass.getuser()
if process.username != current_user and process.username != "root":
# We're on Unix and don't own the process
if self.platform != "Windows":
return False, "需要管理员权限终止此进程"
return True, "可以终止"
def check_and_handle_locked_files(
self,
files: List[FileInfo],
auto_terminate: bool = False,
) -> Tuple[List[str], List[FileInfo]]:
"""
Check for locked files and optionally terminate processes.
Args:
files: List of FileInfo objects to check.
auto_terminate: If True, auto-terminate without asking.
Returns:
Tuple of (unlocked_file_paths, locked_file_list).
"""
unlocked = []
locked = []
for file_info in files:
try:
# Try to open file exclusively
fd = os.open(file_info.path, os.O_EXCL | os.O_RDWR)
os.close(fd)
unlocked.append(file_info.path)
except OSError:
# File is locked
locking_processes = self.get_locking_processes(file_info.path)
if locking_processes:
file_info.locking_processes = locking_processes # type: ignore
locked.append(file_info)
if auto_terminate:
for process in locking_processes:
can_term, reason = self.can_terminate_process(process)
if can_term:
self.terminate_process(process)
return unlocked, locked
diskcleaner/core/progress.py
"""
Zero-dependency progress bar implementation.
This module provides a simple, zero-dependency progress bar for disk cleaner operations.
Features:
- Real-time progress display with percentage
- ETA calculation
- Current item display
- Auto-disable in non-TTY environments
- Refresh rate limiting to avoid flicker
"""
import sys
import time
from typing import Optional
class ProgressBar:
"""
A simple, zero-dependency progress bar.
Usage:
>>> progress = ProgressBar(100, prefix="Scanning")
>>> for i in range(100):
... # Do work
... progress.update(1, f"file_{i}.txt")
>>> progress.close()
Display format:
Scanning [████████░░░░░░] 45.2% (1234/2718) | ETA: 0:15 | /tmp/file.log
"""
def __init__(
self, total: int, prefix: str = "", width: int = 40, enable: Optional[bool] = None
):
"""
Initialize progress bar.
Args:
total: Total number of items to process
prefix: Text to display before the progress bar
width: Width of the progress bar in characters
enable: Force enable/disable. None = auto-detect TTY
"""
self.total = total
self.current = 0
self.prefix = prefix
self.width = width
self.start_time = time.time()
self.last_update_time = 0
self.last_display_length = 0
self.closed = False
# Auto-detect TTY if not specified
if enable is None:
self.enabled = sys.stdout.isatty()
else:
self.enabled = enable
# Minimum refresh interval (seconds) to avoid flicker
self.min_refresh_interval = 0.1
# For unknown total (indeterminate progress)
if total <= 0:
self.total = 0
self.enabled = False # Disable for unknown total
def update(self, n: int = 1, item: str = ""):
"""
Update progress.
Args:
n: Number of items processed since last update
item: Current item being processed (optional)
"""
# Always update counter, even if disabled
self.current = min(self.current + n, self.total) # Cap at total
current_time = time.time()
if not self.enabled or self.closed:
return
# Rate limiting: only update if enough time has passed
# or if we're at 100%
time_since_last_update = current_time - self.last_update_time
is_complete = self.current >= self.total
if time_since_last_update < self.min_refresh_interval and not is_complete:
return
# Build progress string
progress_str = self._format_progress(item)
# Clear previous line by writing spaces
if self.last_display_length > 0:
clear_str = "\r" + " " * self.last_display_length + "\r"
sys.stdout.write(clear_str)
# Write new progress
sys.stdout.write(f"\r{progress_str}")
sys.stdout.flush()
# Update state
self.last_update_time = current_time
self.last_display_length = len(progress_str)
# Newline when complete
if is_complete:
sys.stdout.write("\n")
sys.stdout.flush()
self.closed = True
def _format_progress(self, item: str = "") -> str:
"""Format the progress display string."""
if self.total == 0:
return f"{self.prefix}: {self.current} items processed"
# Calculate percentage
percent = self.current / self.total
percent_str = f"{percent * 100:.1f}%"
# Build progress bar
filled = int(self.width * percent)
bar = "█" * filled + "░" * (self.width - filled)
# Calculate ETA
elapsed = time.time() - self.start_time
if self.current > 0 and percent < 1.0 and elapsed > 0:
items_per_second = self.current / elapsed
remaining_items = self.total - self.current
eta_seconds = remaining_items / items_per_second if items_per_second > 0 else 0
eta_str = self._format_time(eta_seconds)
else:
eta_str = "0:00"
# Build components
parts = [
self.prefix,
f"[{bar}]",
f"{percent_str}",
f"({self.current}/{self.total})",
f"ETA: {eta_str}",
]
# Add current item if provided
if item:
# Truncate long item names
max_item_length = 50
if len(item) > max_item_length:
item = "..." + item[-(max_item_length - 3) :]
parts.append(f"| {item}")
return " ".join(parts)
def _format_time(self, seconds: float) -> str:
"""Format time in MM:SS or HH:MM:SS format."""
if seconds < 60:
return f"{int(seconds)}s"
elif seconds < 3600:
mins = int(seconds // 60)
secs = int(seconds % 60)
return f"{mins}:{secs:02d}"
else:
hours = int(seconds // 3600)
mins = int((seconds % 3600) // 60)
secs = int(seconds % 60)
return f"{hours}:{mins:02d}:{secs:02d}"
def close(self):
"""Finalize the progress bar."""
if self.closed:
return
# Ensure we show 100%
if self.current < self.total:
self.current = self.total
if self.enabled:
progress_str = self._format_progress()
sys.stdout.write(f"\r{progress_str}\n")
sys.stdout.flush()
self.closed = True
def __enter__(self):
"""Context manager entry."""
return self
def __exit__(self, exc_type, exc_val, exc_tb):
"""Context manager exit."""
self.close()
return False
class IndeterminateProgress:
"""
Indeterminate progress bar for operations with unknown total.
Shows a spinning indicator instead of percentage.
Usage:
>>> progress = IndeterminateProgress("Processing")
>>> while True:
... # Do work
... progress.tick()
... if done:
... break
>>> progress.close()
"""
# Spinner frames
_spinner_frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
def __init__(self, prefix: str = "", enable: Optional[bool] = None):
"""
Initialize indeterminate progress.
Args:
prefix: Text to display before the spinner
enable: Force enable/disable. None = auto-detect TTY
"""
self.prefix = prefix
self.enabled = enable if enable is not None else sys.stdout.isatty()
self.closed = False
self.frame_index = 0
self.item_count = 0
self.start_time = time.time()
self.last_update_time = 0
def tick(self, item: str = ""):
"""
Update the spinner.
Args:
item: Current item being processed (optional)
"""
# Always update counter and frame, even if disabled
self.item_count += 1
current_time = time.time()
# Update frame index regardless of enabled status
self.frame_index = (self.frame_index + 1) % len(self._spinner_frames)
if not self.enabled or self.closed:
return
# Rate limiting
if current_time - self.last_update_time < 0.1:
return
# Get current frame
frame = self._spinner_frames[self.frame_index]
# Calculate elapsed time
elapsed = time.time() - self.start_time
elapsed_str = self._format_time(elapsed)
# Build display
parts = [self.prefix, f"{frame}", f"({self.item_count} items)", f"elapsed: {elapsed_str}"]
if item:
max_item_length = 50
if len(item) > max_item_length:
item = "..." + item[-(max_item_length - 3) :]
parts.append(f"| {item}")
display_str = " ".join(parts)
# Update display
sys.stdout.write(f"\r{display_str}")
sys.stdout.flush()
self.last_update_time = current_time
def _format_time(self, seconds: float) -> str:
"""Format time in MM:SS or HH:MM:SS format."""
if seconds < 60:
return f"{int(seconds)}s"
elif seconds < 3600:
mins = int(seconds // 60)
secs = int(seconds % 60)
return f"{mins}:{secs:02d}"
else:
hours = int(seconds // 3600)
mins = int((seconds % 3600) // 60)
secs = int(seconds % 60)
return f"{hours}:{mins:02d}:{secs:02d}"
def close(self):
"""Finalize the progress display."""
if self.closed:
return
if self.enabled:
elapsed = time.time() - self.start_time
elapsed_str = self._format_time(elapsed)
# Show completion message
sys.stdout.write(
f"\r{self.prefix} ✓ Completed ({self.item_count} items in {elapsed_str})\n"
)
sys.stdout.flush()
self.closed = True
def __enter__(self):
"""Context manager entry."""
return self
def __exit__(self, exc_type, exc_val, exc_tb):
"""Context manager exit."""
self.close()
return False
def progress_iterator(items, prefix: str = "", enable: Optional[bool] = None):
"""
Wrap an iterator with automatic progress tracking.
Usage:
>>> for item in progress_iterator(my_list, "Processing"):
... process(item)
Args:
items: Iterable to process
prefix: Progress bar prefix
enable: Force enable/disable progress bar
Yields:
Items from the input iterable
"""
# Try to get length for determinate progress
try:
total = len(items)
progress = ProgressBar(total, prefix, enable=enable)
except (TypeError, AttributeError):
# Fallback to indeterminate progress
progress = IndeterminateProgress(prefix, enable=enable)
with progress:
for item in items:
yield item
if isinstance(progress, ProgressBar):
progress.update(1, str(item)[:50])
else:
progress.tick(str(item)[:50])
diskcleaner/core/rules/__init__.py
"""
File organization rules module.
Provides predefined strategies for organizing files
and custom rule engine for flexible categorization.
"""
from .archive_rules import (
ArchiveRule,
ArchiveStrategy,
DesktopStrategy,
DownloadsStrategy,
GeneralStrategy,
ProjectStrategy,
RuleEngine,
)
__all__ = [
"ArchiveRule",
"ArchiveStrategy",
"DesktopStrategy",
"DownloadsStrategy",
"ProjectStrategy",
"GeneralStrategy",
"RuleEngine",
]
diskcleaner/core/rules/archive_rules.py
"""
Archive rules for file organization.
Defines predefined strategies and rule engine for
intelligent file categorization and organization.
"""
import fnmatch
import re
from abc import ABC, abstractmethod
from dataclasses import dataclass
from datetime import datetime, timedelta
from enum import Enum
from pathlib import Path
from typing import Callable, Dict, List, Optional, Tuple
from diskcleaner.core.scanner import FileInfo
class RuleType(Enum):
"""Types of archive rules."""
EXTENSION = "extension"
PATTERN = "pattern"
AGE = "age"
SIZE = "size"
PATH = "path"
CUSTOM = "custom"
@dataclass
class ArchiveRule:
"""
A rule for organizing files.
Attributes:
name: Rule name for identification.
description: Human-readable description.
rule_type: Type of rule (extension, pattern, age, etc.).
destination: Target directory path (relative to base).
priority: Higher priority rules are evaluated first.
condition: Function that returns True if file matches rule.
transform: Optional function to transform destination path.
"""
name: str
description: str
rule_type: RuleType
destination: str
priority: int = 0
condition: Optional[Callable[[FileInfo], bool]] = None
transform: Optional[Callable[[str, FileInfo], str]] = None
def matches(self, file: FileInfo) -> bool:
"""
Check if file matches this rule.
Args:
file: FileInfo object to check.
Returns:
True if file matches rule, False otherwise.
"""
if self.condition is None:
return True
return self.condition(file)
def get_destination(self, file: FileInfo) -> str:
"""
Get destination path for file.
Args:
file: FileInfo object.
Returns:
Destination path (possibly transformed).
"""
dest = self.destination
if self.transform:
dest = self.transform(dest, file)
return dest
class ArchiveStrategy(ABC):
"""
Abstract base class for archive strategies.
Each strategy defines a set of rules for organizing files
in a specific way (e.g., desktop, downloads, project).
"""
def __init__(self, name: str, description: str):
"""
Initialize strategy.
Args:
name: Strategy name.
description: Human-readable description.
"""
self.name = name
self.description = description
self.rules: List[ArchiveRule] = []
@abstractmethod
def get_rules(self) -> List[ArchiveRule]:
"""
Get all rules for this strategy.
Returns:
List of ArchiveRule objects sorted by priority.
"""
pass
def organize_file(self, file: FileInfo) -> Optional[str]:
"""
Determine where to organize a file.
Args:
file: FileInfo object to organize.
Returns:
Destination path, or None if no rule matches.
"""
for rule in self.get_rules():
if rule.matches(file):
return rule.get_destination(file)
return None
class DesktopStrategy(ArchiveStrategy):
"""
Desktop organization strategy.
Organizes files by type into categories:
- Images
- Documents
- Media
- Archives
- Code
- Other
"""
def __init__(self):
super().__init__(
name="desktop",
description="Organize desktop files by type",
)
self.rules = self._build_rules()
def _build_rules(self) -> List[ArchiveRule]:
"""Build desktop organization rules."""
rules = []
# Images
rules.append(
ArchiveRule(
name="images",
description="Image files (PNG, JPG, GIF, etc.)",
rule_type=RuleType.EXTENSION,
destination="Images",
priority=100,
condition=lambda f: f.name.lower().endswith(
(
".png",
".jpg",
".jpeg",
".gif",
".bmp",
".svg",
".webp",
".ico",
)
),
)
)
# Documents
rules.append(
ArchiveRule(
name="documents",
description="Document files (PDF, DOC, TXT, etc.)",
rule_type=RuleType.EXTENSION,
destination="Documents",
priority=90,
condition=lambda f: f.name.lower().endswith(
(
".pdf",
".doc",
".docx",
".txt",
".rtf",
".odt",
".xls",
".xlsx",
".ppt",
".pptx",
".csv",
)
),
)
)
# Media (audio/video)
rules.append(
ArchiveRule(
name="media",
description="Audio and video files",
rule_type=RuleType.EXTENSION,
destination="Media",
priority=80,
condition=lambda f: f.name.lower().endswith(
(
".mp4",
".mkv",
".avi",
".mov",
".mp3",
".flac",
".wav",
".m4a",
".wmv",
)
),
)
)
# Archives
rules.append(
ArchiveRule(
name="archives",
description="Compressed archives",
rule_type=RuleType.EXTENSION,
destination="Archives",
priority=70,
condition=lambda f: f.name.lower().endswith(
(".zip", ".tar", ".gz", ".rar", ".7z", ".bz2")
),
)
)
# Code files
rules.append(
ArchiveRule(
name="code",
description="Programming source code",
rule_type=RuleType.EXTENSION,
destination="Code",
priority=60,
condition=lambda f: f.name.lower().endswith(
(
".py",
".js",
".ts",
".java",
".c",
".cpp",
".h",
".cs",
".go",
".rs",
".php",
".rb",
".swift",
".kt",
".scala",
".sh",
".bat",
".ps1",
".html",
".css",
".json",
".xml",
".yaml",
".yml",
)
),
)
)
# Executables and installers
rules.append(
ArchiveRule(
name="executables",
description="Executable files and installers",
rule_type=RuleType.EXTENSION,
destination="Installers",
priority=50,
condition=lambda f: f.name.lower().endswith(
(".exe", ".msi", ".app", ".dmg", ".deb", ".rpm", ".apk")
),
)
)
return sorted(rules, key=lambda r: r.priority, reverse=True)
def get_rules(self) -> List[ArchiveRule]:
"""Get desktop rules."""
return self.rules
class DownloadsStrategy(ArchiveStrategy):
"""
Downloads organization strategy.
Organizes files by type and date:
- Documents/2024-04/
- Images/2024-04/
- Installers/2024-04/
- Archives/2024-04/
- Other/
"""
def __init__(self):
super().__init__(
name="downloads",
description="Organize downloads by type and date",
)
self.rules = self._build_rules()
def _build_rules(self) -> List[ArchiveRule]:
"""Build downloads organization rules."""
rules = []
# Helper to add date prefix
def add_date_prefix(dest: str, file: FileInfo) -> str:
date_str = datetime.fromtimestamp(file.mtime).strftime("%Y-%m")
return f"{dest}/{date_str}"
# Documents with date
rules.append(
ArchiveRule(
name="documents_by_date",
description="Documents organized by date",
rule_type=RuleType.EXTENSION,
destination="Documents",
priority=100,
condition=lambda f: f.name.lower().endswith(
(
".pdf",
".doc",
".docx",
".txt",
".xls",
".xlsx",
".ppt",
".pptx",
)
),
transform=add_date_prefix,
)
)
# Images with date
rules.append(
ArchiveRule(
name="images_by_date",
description="Images organized by date",
rule_type=RuleType.EXTENSION,
destination="Images",
priority=90,
condition=lambda f: f.name.lower().endswith(
(".png", ".jpg", ".jpeg", ".gif", ".bmp", ".svg", ".webp")
),
transform=add_date_prefix,
)
)
# Media with date
rules.append(
ArchiveRule(
name="media_by_date",
description="Audio/video organized by date",
rule_type=RuleType.EXTENSION,
destination="Media",
priority=80,
condition=lambda f: f.name.lower().endswith(
(".mp4", ".mkv", ".avi", ".mov", ".mp3", ".flac", ".wav")
),
transform=add_date_prefix,
)
)
# Installers with date
rules.append(
ArchiveRule(
name="installers_by_date",
description="Installers organized by date",
rule_type=RuleType.EXTENSION,
destination="Installers",
priority=70,
condition=lambda f: f.name.lower().endswith(
(".exe", ".msi", ".app", ".dmg", ".deb", ".rpm")
),
transform=add_date_prefix,
)
)
# Archives with date
rules.append(
ArchiveRule(
name="archives_by_date",
description="Archives organized by date",
rule_type=RuleType.EXTENSION,
destination="Archives",
priority=60,
condition=lambda f: f.name.lower().endswith((".zip", ".tar", ".gz", ".rar", ".7z")),
transform=add_date_prefix,
)
)
return sorted(rules, key=lambda r: r.priority, reverse=True)
def get_rules(self) -> List[ArchiveRule]:
"""Get downloads rules."""
return self.rules
class ProjectStrategy(ArchiveStrategy):
"""
Project organization strategy.
Organizes files by project and semantic grouping:
- Projects/{project-name}/Source
- Projects/{project-name}/Docs
- Projects/{project-name}/Assets
- Projects/{project-name}/Build
"""
def __init__(self):
super().__init__(
name="project",
description="Organize files by project",
)
self.rules = self._build_rules()
def _build_rules(self) -> List[ArchiveRule]:
"""Build project organization rules."""
rules = []
# Detect project from path
def detect_project(file: FileInfo) -> Optional[str]:
"""Try to detect project name from file path."""
path_parts = Path(file.path).parts
# Common project indicators
project_indicators = [
"src",
"source",
"project",
"projects",
"dev",
"development",
"code",
"workspace",
"work",
]
# Find project directory
for i, part in enumerate(path_parts):
if part.lower() in project_indicators and i + 1 < len(path_parts):
return path_parts[i + 1]
# Check for known project structures
for i, part in enumerate(path_parts):
# Look for git repository
if part == ".git" and i > 0:
return path_parts[i - 1]
return None
def get_project_dest(dest: str, file: FileInfo) -> str:
"""Transform destination to include project name."""
project = detect_project(file)
if project:
return f"Projects/{project}/{dest}"
return f"Projects/Unknown/{dest}"
# Source code
rules.append(
ArchiveRule(
name="project_source",
description="Project source code",
rule_type=RuleType.CUSTOM,
destination="Source",
priority=100,
condition=lambda f: f.name.lower().endswith(
(
".py",
".js",
".ts",
".java",
".c",
".cpp",
".h",
".cs",
".go",
".rs",
".php",
".rb",
)
),
transform=get_project_dest,
)
)
# Documentation
rules.append(
ArchiveRule(
name="project_docs",
description="Project documentation",
rule_type=RuleType.CUSTOM,
destination="Docs",
priority=90,
condition=lambda f: f.name.lower().endswith(
(".md", ".rst", ".txt", ".pdf", ".doc", ".docx")
)
or f.name.lower().startswith("readme"),
transform=get_project_dest,
)
)
# Assets
rules.append(
ArchiveRule(
name="project_assets",
description="Project assets (images, fonts, etc.)",
rule_type=RuleType.CUSTOM,
destination="Assets",
priority=80,
condition=lambda f: f.name.lower().endswith(
(".png", ".jpg", ".jpeg", ".gif", ".svg", ".woff", ".woff2", ".ttf")
),
transform=get_project_dest,
)
)
# Build artifacts
rules.append(
ArchiveRule(
name="project_build",
description="Project build artifacts",
rule_type=RuleType.CUSTOM,
destination="Build",
priority=70,
condition=lambda f: any(
pattern in f.path.lower()
for pattern in ["build", "dist", "target", "out", "bin", "obj"]
)
or f.name.lower().endswith((".o", ".so", ".dll", ".exe")),
transform=get_project_dest,
)
)
return sorted(rules, key=lambda r: r.priority, reverse=True)
def get_rules(self) -> List[ArchiveRule]:
"""Get project rules."""
return self.rules
class GeneralStrategy(ArchiveStrategy):
"""
General organization strategy.
Mixed strategy combining type, size, and age:
- Large files (>100MB) -> Large Files/
- Recent files (<7 days) -> Recent/
- Old files (>90 days) -> Archive/
- By type -> Documents, Images, Media, etc.
"""
def __init__(self):
super().__init__(
name="general",
description="General purpose organization",
)
self.rules = self._build_rules()
def _build_rules(self) -> List[ArchiveRule]:
"""Build general organization rules."""
rules = []
large_threshold = 100 * 1024 * 1024 # 100 MB
# Large files
rules.append(
ArchiveRule(
name="large_files",
description="Files larger than 100MB",
rule_type=RuleType.SIZE,
destination="Large Files",
priority=100,
condition=lambda f: f.size > large_threshold,
)
)
# Recent files
rules.append(
ArchiveRule(
name="recent_files",
description="Files modified in last 7 days",
rule_type=RuleType.AGE,
destination="Recent",
priority=90,
condition=lambda f: (datetime.now().timestamp() - f.mtime)
< timedelta(days=7).total_seconds(),
)
)
# Old files
rules.append(
ArchiveRule(
name="archive_files",
description="Files not modified in 90 days",
rule_type=RuleType.AGE,
destination="Archive",
priority=80,
condition=lambda f: (datetime.now().timestamp() - f.mtime)
> timedelta(days=90).total_seconds(),
)
)
# Documents
rules.append(
ArchiveRule(
name="documents",
description="Document files",
rule_type=RuleType.EXTENSION,
destination="Documents",
priority=70,
condition=lambda f: f.name.lower().endswith(
(".pdf", ".doc", ".docx", ".txt", ".xls", ".xlsx", ".ppt", ".pptx")
),
)
)
# Images
rules.append(
ArchiveRule(
name="images",
description="Image files",
rule_type=RuleType.EXTENSION,
destination="Images",
priority=60,
condition=lambda f: f.name.lower().endswith(
(".png", ".jpg", ".jpeg", ".gif", ".bmp", ".svg", ".webp")
),
)
)
# Media
rules.append(
ArchiveRule(
name="media",
description="Audio and video files",
rule_type=RuleType.EXTENSION,
destination="Media",
priority=50,
condition=lambda f: f.name.lower().endswith(
(".mp4", ".mkv", ".avi", ".mov", ".mp3", ".flac", ".wav")
),
)
)
# Archives
rules.append(
ArchiveRule(
name="archives",
description="Compressed archives",
rule_type=RuleType.EXTENSION,
destination="Archives",
priority=40,
condition=lambda f: f.name.lower().endswith((".zip", ".tar", ".gz", ".rar", ".7z")),
)
)
return sorted(rules, key=lambda r: r.priority, reverse=True)
def get_rules(self) -> List[ArchiveRule]:
"""Get general rules."""
return self.rules
class RuleEngine:
"""
Rule engine for file organization.
Manages strategies and rules, provides matching
and destination resolution for files.
"""
def __init__(self):
"""Initialize rule engine."""
self.strategies: Dict[str, ArchiveStrategy] = {}
self._register_builtin_strategies()
def _register_builtin_strategies(self):
"""Register built-in strategies."""
self.strategies["desktop"] = DesktopStrategy()
self.strategies["downloads"] = DownloadsStrategy()
self.strategies["project"] = ProjectStrategy()
self.strategies["general"] = GeneralStrategy()
def register_strategy(self, strategy: ArchiveStrategy):
"""
Register a custom strategy.
Args:
strategy: ArchiveStrategy instance.
"""
self.strategies[strategy.name] = strategy
def get_strategy(self, name: str) -> Optional[ArchiveStrategy]:
"""
Get strategy by name.
Args:
name: Strategy name.
Returns:
ArchiveStrategy instance or None.
"""
return self.strategies.get(name)
def list_strategies(self) -> List[str]:
"""
List available strategies.
Returns:
List of strategy names.
"""
return list(self.strategies.keys())
def organize_file(self, file: FileInfo, strategy_name: str) -> Optional[str]:
"""
Organize a file using specified strategy.
Args:
file: FileInfo object.
strategy_name: Name of strategy to use.
Returns:
Destination path, or None if no rule matches.
"""
strategy = self.get_strategy(strategy_name)
if not strategy:
raise ValueError(f"Unknown strategy: {strategy_name}")
return strategy.organize_file(file)
def organize_files(
self, files: List[FileInfo], strategy_name: str
) -> Dict[str, List[FileInfo]]:
"""
Organize multiple files using strategy.
Args:
files: List of FileInfo objects.
strategy_name: Name of strategy to use.
Returns:
Dictionary mapping destinations to file lists.
"""
strategy = self.get_strategy(strategy_name)
if not strategy:
raise ValueError(f"Unknown strategy: {strategy_name}")
organized: Dict[str, List[FileInfo]] = {}
for file in files:
dest = strategy.organize_file(file)
if dest:
if dest not in organized:
organized[dest] = []
organized[dest].append(file)
return organized
def add_custom_rule(
self,
strategy_name: str,
rule: ArchiveRule,
):
"""
Add a custom rule to a strategy.
Args:
strategy_name: Strategy to modify.
rule: Rule to add.
"""
strategy = self.get_strategy(strategy_name)
if not strategy:
raise ValueError(f"Unknown strategy: {strategy_name}")
strategy.rules.append(rule)
# Re-sort by priority
strategy.rules.sort(key=lambda r: r.priority, reverse=True)
def create_rule_from_dict(self, rule_dict: Dict) -> ArchiveRule:
"""
Create ArchiveRule from dictionary.
Args:
rule_dict: Dictionary with rule configuration.
Returns:
ArchiveRule instance.
Example:
{
"name": "my_rule",
"description": "My custom rule",
"type": "extension",
"destination": "MyFolder",
"priority": 50,
"patterns": ["*.txt", "*.md"]
}
"""
rule_type = RuleType(rule_dict.get("type", "custom"))
# Build condition based on type
condition = None
patterns = rule_dict.get("patterns", [])
if rule_type == RuleType.EXTENSION and patterns:
extensions = tuple(p.replace("*", "") for p in patterns)
condition = lambda f, ext=extensions: f.name.lower().endswith(ext)
elif rule_type == RuleType.PATTERN and patterns:
condition = lambda f, pats=patterns: any(fnmatch.fnmatch(f.name, pat) for pat in pats)
return ArchiveRule(
name=rule_dict["name"],
description=rule_dict.get("description", ""),
rule_type=rule_type,
destination=rule_dict["destination"],
priority=rule_dict.get("priority", 0),
condition=condition,
)
diskcleaner/core/safety.py
"""
Safety checker for file deletion operations.
Provides comprehensive safety checks including file lock detection,
permission verification, and process termination capabilities.
"""
import os
import platform
import shutil
import subprocess
from datetime import datetime
from enum import Enum
from pathlib import Path
from typing import Any, Dict, List, Optional, Tuple
from diskcleaner.config import Config
from diskcleaner.core.scanner import FileInfo
class FileStatus(Enum):
"""Status of a file for deletion."""
SAFE = "safe"
LOCKED = "locked"
NO_PERMISSION = "no_permission"
PROTECTED = "protected"
ERROR = "error"
class SafetyChecker:
"""
Performs safety checks before file deletion.
Features:
- Protected path and extension checking
- File lock detection (cross-platform)
- Permission verification
- Process termination (optional)
- Backup creation (optional)
"""
def __init__(self, config: Optional[Config] = None):
"""
Initialize safety checker.
Args:
config: Configuration object.
"""
self.config = config or Config.load()
self.platform = platform.system()
# Load settings
self.check_locks = self.config.check_file_locks
self.verify_perms = self.config.verify_permissions
self.backup_enabled = self.config.get("safety.backup_before_delete", False)
# Protected paths and extensions
self.protected_paths = self.config.protected_paths
self.protected_extensions = self.config.protected_extensions
self.protected_patterns = self.config.protected_patterns
# Backup directory
self.backup_dir = Path.home() / ".disk-cleaner" / "backup"
def verify_all(self, files: List[FileInfo]) -> List[Tuple[FileInfo, FileStatus]]:
"""
Verify all files are safe to delete.
Args:
files: List of FileInfo objects.
Returns:
List of (FileInfo, FileStatus) tuples.
"""
results = []
for file in files:
if file.is_dir:
# Skip directories for now (handle separately)
continue
status = self.verify_file(file)
results.append((file, status))
return results
def verify_file(self, file: FileInfo) -> FileStatus:
"""
Verify if a single file is safe to delete.
Args:
file: FileInfo object.
Returns:
FileStatus indicating if file is safe to delete.
"""
# Check protected paths
if self._is_protected_path(file.path):
return FileStatus.PROTECTED
# Check protected extensions
if self._is_protected_extension(file.name):
return FileStatus.PROTECTED
# Check protected patterns
if self._is_protected_pattern(file.name):
return FileStatus.PROTECTED
# Check file locks
if self.check_locks:
if self._is_locked(file.path):
return FileStatus.LOCKED
# Check permissions
if self.verify_perms:
if not self._has_write_permission(file.path):
return FileStatus.NO_PERMISSION
return FileStatus.SAFE
def _is_protected_path(self, path: str) -> bool:
"""
Check if path is in protected list.
Args:
path: File path to check.
Returns:
True if path is protected.
"""
# Normalize path
path = os.path.normpath(path)
for protected in self.protected_paths:
protected = os.path.normpath(protected)
if path.startswith(protected):
return True
return False
def _is_protected_extension(self, filename: str) -> bool:
"""
Check if file has protected extension.
Args:
filename: File name to check.
Returns:
True if extension is protected.
"""
# Get extension (lowercase)
ext = os.path.splitext(filename)[1].lower()
return ext in self.protected_extensions
def _is_protected_pattern(self, filename: str) -> bool:
"""
Check if filename matches protected pattern.
Args:
filename: File name to check.
Returns:
True if pattern matches.
"""
import fnmatch
for pattern in self.protected_patterns:
if fnmatch.fnmatch(filename, pattern):
return True
return False
def _is_locked(self, path: str) -> bool:
"""
Check if file is locked by a process.
Args:
path: File path to check.
Returns:
True if file is locked.
"""
if self.platform == "Windows":
return self._is_locked_windows(path)
elif self.platform in ["Linux", "Darwin"]:
return self._is_locked_unix(path)
return False
def _is_locked_windows(self, path: str) -> bool:
"""
Check if file is locked on Windows.
Args:
path: File path to check.
Returns:
True if file is locked.
"""
try:
# Try to open file with exclusive access
# This will fail if another process has it open
fd = os.open(path, os.O_EXCL | os.O_RDWR)
os.close(fd)
return False
except (OSError, IOError):
return True
def _is_locked_unix(self, path: str) -> bool:
"""
Check if file is locked on Unix/Linux/macOS.
Uses lsof command to detect open files.
Args:
path: File path to check.
Returns:
True if file is locked.
"""
try:
# Use lsof to check if file is open
result = subprocess.run(
["lsof", "-t", path],
capture_output=True,
timeout=5,
text=True,
)
return result.returncode == 0
except (subprocess.TimeoutExpired, FileNotFoundError):
# lsof not available or timeout, assume not locked
return False
def _has_write_permission(self, path: str) -> bool:
"""
Check if we have write permission for file.
Args:
path: File path to check.
Returns:
True if we have write permission.
"""
return os.access(path, os.W_OK)
def get_locking_process(self, path: str) -> Optional[Dict[str, Any]]:
"""
Get information about process locking the file.
Args:
path: File path to check.
Returns:
Dictionary with process info, or None if not locked.
"""
if self.platform == "Windows":
return self._get_locking_process_windows(path)
elif self.platform in ["Linux", "Darwin"]:
return self._get_locking_process_unix(path)
return None
def _get_locking_process_windows(self, path: str) -> Optional[Dict[str, Any]]:
"""
Get process info on Windows.
Uses handle.exe from Sysinternals if available,
otherwise returns limited info.
Args:
path: File path to check.
Returns:
Dictionary with process info, or None.
"""
try:
# Try using handle.exe (if installed)
result = subprocess.run(
["handle", path],
capture_output=True,
timeout=10,
text=True,
)
if result.returncode == 0:
# Parse output to extract PID and process name
# Output format: python.exe pid: 12345 type: File
for line in result.stdout.split("\n"):
if path.lower() in line.lower():
parts = line.split()
if len(parts) >= 4:
return {
"name": parts[0],
"pid": int(parts[2].rstrip(",")),
"type": parts[4],
}
except (subprocess.TimeoutExpired, FileNotFoundError, ValueError):
pass
# Fallback: return generic info
return {
"name": "unknown",
"pid": -1,
"type": "File",
}
def _get_locking_process_unix(self, path: str) -> Optional[Dict[str, Any]]:
"""
Get process info on Unix/Linux/macOS.
Args:
path: File path to check.
Returns:
Dictionary with process info, or None.
"""
try:
# Get PID using lsof
result = subprocess.run(
["lsof", "-t", path],
capture_output=True,
timeout=5,
text=True,
)
if result.returncode == 0:
pid = int(result.stdout.strip())
# Get process name using ps
cmd_result = subprocess.run(
["ps", "-p", str(pid), "-o", "comm="],
capture_output=True,
timeout=5,
text=True,
)
if cmd_result.returncode == 0:
return {
"name": cmd_result.stdout.strip(),
"pid": pid,
}
except (subprocess.TimeoutExpired, FileNotFoundError, ValueError):
pass
return None
def terminate_process(self, pid: int) -> bool:
"""
Terminate a process by PID.
Args:
pid: Process ID to terminate.
Returns:
True if successful, False otherwise.
"""
try:
if self.platform == "Windows":
subprocess.run(
["taskkill", "/F", "/PID", str(pid)],
check=True,
timeout=10,
capture_output=True,
)
else:
subprocess.run(
["kill", "-9", str(pid)],
check=True,
timeout=10,
capture_output=True,
)
return True
except (subprocess.CalledProcessError, subprocess.TimeoutExpired):
return False
def show_process_details(self, process: Dict[str, Any]) -> str:
"""
Get detailed information about a process.
Args:
process: Process info dictionary.
Returns:
Formatted string with process details.
"""
details = f"Process: {process['name']} (PID: {process['pid']})\n"
try:
if self.platform == "Windows":
result = subprocess.run(
["tasklist", "/FI", f"PID eq {process['pid']}", "/FO", "CSV"],
capture_output=True,
timeout=5,
text=True,
)
details += f"\n{result.stdout}"
else:
result = subprocess.run(
["ps", "-p", str(process["pid"]), "-o", "etime,%cpu,rss,cmd"],
capture_output=True,
timeout=5,
text=True,
)
details += f"\n{result.stdout}"
except (subprocess.TimeoutExpired, FileNotFoundError):
pass
return details
def create_backup(self, file_path: str) -> Optional[str]:
"""
Create backup of a file before deletion.
Args:
file_path: Path to file to backup.
Returns:
Path to backup file, or None if failed.
"""
if not self.backup_enabled:
return None
try:
# Create backup directory for today
today = datetime.now().strftime("%Y-%m-%d")
backup_dir = self.backup_dir / today
backup_dir.mkdir(parents=True, exist_ok=True)
# Create backup filename
original_name = Path(file_path).name
backup_path = backup_dir / original_name
# Handle duplicate names
counter = 1
while backup_path.exists():
stem = Path(file_path).stem
suffix = Path(file_path).suffix
backup_path = backup_dir / f"{stem}_{counter}{suffix}"
counter += 1
# Copy file
shutil.copy2(file_path, backup_path)
# Log backup
self._log_backup(file_path, backup_path)
return str(backup_path)
except (OSError, IOError):
# Log error but don't fail
return None
def _log_backup(self, original: str, backup: str) -> None:
"""
Log backup operation.
Args:
original: Original file path.
backup: Backup file path.
"""
log_dir = Path.home() / ".disk-cleaner" / "logs"
log_dir.mkdir(parents=True, exist_ok=True)
log_file = log_dir / "backup.log"
timestamp = datetime.now().isoformat()
log_entry = f"{timestamp} | {original} -> {backup}\n"
try:
with open(str(log_file), "a", encoding="utf-8") as f:
f.write(log_entry)
except (OSError, IOError):
pass
diskcleaner/core/scanner.py
"""
Directory scanner with incremental scanning support.
Scans directories to collect file information with support for
incremental updates using cached metadata.
Performance optimizations:
- Uses os.scandir() instead of Path.iterdir() for 3-5x better performance
- Cross-platform path exclusions to avoid scanning system directories
- Early stopping mechanism to prevent over-scanning
- Efficient stat caching from DirEntry objects
"""
import os
import platform
import time
from dataclasses import dataclass
from pathlib import Path
from typing import Generator, List, Optional, Set, Tuple
from diskcleaner.config import Config
from diskcleaner.core.cache import CacheManager, FileSnapshot, ScanSnapshot
# Cross-platform path exclusions
PLATFORM_EXCLUDES = {
"windows": [
"C:\\Windows",
"C:\\Program Files",
"C:\\Program Files (x86)",
"C:\\ProgramData",
"C:\\$Recycle.Bin",
"C:\\System Volume Information",
"C:\\Boot",
"C:\\EFI",
"C:\\Recovery",
],
"darwin": [
"/System",
"/Library",
"/bin",
"/sbin",
"/usr",
"/.Spotlight-V100",
"/.fseventsd",
"/.vol",
"/private/var/vm", # VM swap files
"/Volumes/MobileBackups",
"/dev",
"/etc",
"/var",
],
"linux": [
"/proc",
"/sys",
"/dev",
"/run",
"/boot",
"/lib",
"/lib64",
"/bin",
"/sbin",
"/etc",
],
}
def should_exclude_path(path: Path, include_windows: bool = False) -> bool:
"""
Check if a path should be excluded from scanning.
Args:
path: Path to check.
include_windows: If True, include Windows system directories.
Returns:
True if path should be excluded, False otherwise.
"""
system = platform.system().lower()
path_str = str(path)
# Check against platform-specific excludes
for exclude_prefix in PLATFORM_EXCLUDES.get(system, []):
if path_str.startswith(exclude_prefix):
# Special handling for Windows directories when include_windows is True
if include_windows and system == "windows":
# Still exclude truly critical system paths
critical_paths = [
"C:\\System Volume Information",
"C:\\$Recycle.Bin",
"C:\\Boot",
"C:\\EFI",
"C:\\Recovery",
]
if not any(path_str.startswith(cp) for cp in critical_paths):
continue
return True
return False
@dataclass
class FileInfo:
"""Information about a single file."""
path: str
name: str
size: int
mtime: float
is_dir: bool
is_link: bool
inode: Optional[int] = None
depth: int = 0
def to_snapshot(self) -> FileSnapshot:
"""Convert to FileSnapshot for caching."""
return FileSnapshot(
path=self.path,
size=self.size,
mtime=self.mtime,
inode=self.inode,
)
class DirectoryScanner:
"""
Directory scanner with incremental scanning support.
Features:
- Incremental scanning using cache
- Parallel scanning capability (optional)
- Configurable depth limits
- Symbolic link handling
- Cross-platform path exclusions
- Early stopping mechanism (max files, max time)
- High-performance os.scandir() implementation
"""
def __init__(
self,
target_path: str,
config: Optional[Config] = None,
cache_enabled: bool = True,
max_files: Optional[int] = None,
max_seconds: Optional[int] = None,
include_windows: bool = False,
):
"""
Initialize scanner.
Args:
target_path: Path to scan.
config: Configuration object.
cache_enabled: Enable incremental scanning with cache.
max_files: Maximum number of files to scan (None = unlimited).
max_seconds: Maximum time to spend scanning (None = unlimited).
include_windows: Include Windows system directories in scan.
"""
self.target_path = Path(target_path).expanduser().resolve()
self.config = config or Config.load()
self.cache_enabled = cache_enabled
# Initialize cache manager
self.cache_manager = (
CacheManager(cache_dir=self.config.cache_dir) if cache_enabled else None
)
# Scan settings
self.follow_symlinks = self.config.get("scan.follow_symlinks", False)
self.max_depth = self.config.get("scan.max_depth", None)
self.parallel_jobs = self.config.get("scan.parallel_jobs", 4)
# Early stopping settings
self.max_files = max_files or self.config.get("scan.max_files", 1000000)
self.max_seconds = max_seconds or self.config.get("scan.max_seconds", 25)
self.include_windows = include_windows
# Scan statistics
self.files_scanned = 0
self.start_time = None
self.stopped_early = False
self.stop_reason = None
def scan(self) -> List[FileInfo]:
"""
Perform a full directory scan.
Returns:
List of FileInfo objects.
"""
files = []
for file_info in self.scan_generator():
files.append(file_info)
return files
def scan_incremental(self) -> Tuple[List[FileInfo], List[str], List[str]]:
"""
Perform incremental scan using cache.
Returns:
Tuple of (all_files, new_files, changed_files):
- all_files: All files in directory (including unchanged)
- new_files: Paths of files added since last scan
- changed_files: Paths of files modified since last scan
"""
# Try to load cached scan
cached_snapshot = None
if self.cache_enabled and self.cache_manager:
cached_snapshot = self.cache_manager.get_scan_cache(
str(self.target_path),
max_age_days=self.config.cache_ttl,
)
# If no cache, do full scan
if cached_snapshot is None:
files = self.scan()
# Save to cache
if self.cache_enabled and self.cache_manager:
snapshot = ScanSnapshot(
path=str(self.target_path),
timestamp=time.time(),
files=[f.to_snapshot() for f in files],
total_size=sum(f.size for f in files),
file_count=len(files),
)
self.cache_manager.save_scan_cache(str(self.target_path), snapshot)
return files, files, [] # All files are "new"
# Incremental scan: compare with cache
cached_files = {f.path: f for f in cached_snapshot.files}
current_files = []
new_files = []
changed_files = []
for file_info in self.scan_generator():
current_files.append(file_info)
cached = cached_files.get(file_info.path)
if cached is None:
# New file
new_files.append(file_info.path)
elif self.cache_manager.is_file_changed(file_info.to_snapshot(), cached):
# Changed file
changed_files.append(file_info.path)
# Detect deleted files
deleted_files = []
current_paths = {f.path for f in current_files}
for cached_path in cached_files:
if cached_path not in current_paths:
deleted_files.append(cached_path)
# Update cache
if self.cache_enabled and self.cache_manager:
snapshot = ScanSnapshot(
path=str(self.target_path),
timestamp=time.time(),
files=[f.to_snapshot() for f in current_files],
total_size=sum(f.size for f in current_files),
file_count=len(current_files),
)
self.cache_manager.save_scan_cache(str(self.target_path), snapshot)
return current_files, new_files, changed_files
def scan_generator(self) -> Generator[FileInfo, None, None]:
"""
Scan directory and yield FileInfo objects.
This is a generator that yields files as they are scanned,
which is more memory-efficient for large directories.
Uses os.scandir() for optimal performance (3-5x faster than glob).
Yields:
FileInfo objects.
"""
if not self.target_path.exists():
raise FileNotFoundError(f"Path not found: {self.target_path}")
if not self.target_path.is_dir():
raise NotADirectoryError(f"Not a directory: {self.target_path}")
# Check if path should be excluded
if should_exclude_path(self.target_path, self.include_windows):
raise PermissionError(f"Path is excluded from scanning: {self.target_path}")
# Initialize scan timing
self.start_time = time.time()
self.files_scanned = 0
self.stopped_early = False
self.stop_reason = None
# Start scanning from root
yield from self._scan_directory_scandir(self.target_path, depth=0)
def _scan_directory_scandir(
self,
directory: Path,
depth: int,
visited: Optional[Set[int]] = None,
) -> Generator[FileInfo, None, None]:
"""
Scan a single directory recursively using os.scandir().
This is 3-5x faster than Path.iterdir() because:
- Uses system-optimized syscalls
- Returns DirEntry with cached stat info
- Avoids extra stat() calls
Args:
directory: Directory to scan.
depth: Current depth.
visited: Set of visited inodes to prevent cycles.
Yields:
FileInfo objects.
"""
if visited is None:
visited = set()
# Check depth limit
if self.max_depth is not None and depth > self.max_depth:
return
# Check early stopping conditions
if self._should_stop_early():
return
try:
# Use os.scandir() for better performance
with os.scandir(directory) as it:
for entry in it:
# Check early stopping before processing each entry
if self._should_stop_early():
break
try:
# Get stat info from DirEntry (cached, no extra syscall)
stat_info = entry.stat(follow_symlinks=False)
# Get inode for cycle detection (Unix only)
inode = None
if hasattr(stat_info, "st_ino"):
inode = stat_info.st_ino
# Check for symlink cycles
# Note: DirEntry.is_symlink() doesn't take arguments
is_link = entry.is_symlink()
if is_link:
if not self.follow_symlinks:
continue
# Check if we've visited this inode
if inode is not None and inode in visited:
continue
visited.add(inode)
# Note: DirEntry.is_dir() doesn't take arguments
is_dir = entry.is_dir()
# Create FileInfo
file_info = FileInfo(
path=entry.path,
name=entry.name,
size=stat_info.st_size if not is_dir else 0,
mtime=stat_info.st_mtime,
is_dir=is_dir,
is_link=is_link,
inode=inode,
depth=depth,
)
self.files_scanned += 1
yield file_info
# Recurse into subdirectories
if is_dir and not is_link:
# Check if subdirectory should be excluded
subpath = Path(entry.path)
if not should_exclude_path(subpath, self.include_windows):
yield from self._scan_directory_scandir(subpath, depth + 1, visited)
except (PermissionError, OSError):
# Skip files we can't access
continue
except (PermissionError, OSError):
# Skip directories we can't read
return
def _should_stop_early(self) -> bool:
"""
Check if we should stop scanning early.
Returns:
True if should stop, False otherwise.
"""
# Check file count limit
if self.max_files and self.files_scanned >= self.max_files:
if not self.stopped_early:
self.stopped_early = True
self.stop_reason = f"file_limit ({self.max_files} files)"
return True
# Check time limit
if self.max_seconds and self.start_time:
elapsed = time.time() - self.start_time
if elapsed >= self.max_seconds:
if not self.stopped_early:
self.stopped_early = True
self.stop_reason = f"time_limit ({self.max_seconds}s)"
return True
return False
def _scan_directory(
self,
directory: Path,
depth: int,
visited: Optional[Set[int]] = None,
) -> Generator[FileInfo, None, None]:
"""
Scan a single directory recursively.
DEPRECATED: Use _scan_directory_scandir() instead.
This method is kept for backward compatibility.
Args:
directory: Directory to scan.
depth: Current depth.
visited: Set of visited inodes to prevent cycles.
Yields:
FileInfo objects.
"""
if visited is None:
visited = set()
# Check depth limit
if self.max_depth is not None and depth > self.max_depth:
return
try:
entries = directory.iterdir()
except PermissionError:
# Skip directories we can't read
return
for entry in entries:
try:
stat_info = entry.lstat()
# Get inode for cycle detection (Unix only)
inode = None
if hasattr(stat_info, "st_ino"):
inode = stat_info.st_ino
# Check for symlink cycles
is_link = entry.is_symlink()
if is_link:
if not self.follow_symlinks:
continue
# Check if we've visited this inode
if inode is not None and inode in visited:
continue
visited.add(inode)
is_dir = entry.is_dir()
# Create FileInfo
file_info = FileInfo(
path=str(entry),
name=entry.name,
size=stat_info.st_size if not is_dir else 0,
mtime=stat_info.st_mtime,
is_dir=is_dir,
is_link=is_link,
inode=inode,
depth=depth,
)
yield file_info
# Recurse into subdirectories
if is_dir and not is_link:
yield from self._scan_directory(entry, depth + 1, visited)
except (PermissionError, OSError):
# Skip files we can't access
continue
def get_directory_size(self, path: Optional[str] = None) -> int:
"""
Calculate total size of a directory.
Args:
path: Path to calculate. If None, uses target_path.
Returns:
Total size in bytes.
"""
target = Path(path) if path else self.target_path
if not target.exists():
return 0
if target.is_file():
return target.stat().st_size
total_size = 0
for file_info in self.scan_generator():
if not file_info.is_dir:
total_size += file_info.size
return total_size
def get_file_count(self, path: Optional[str] = None) -> int:
"""
Count total files in a directory.
Args:
path: Path to count. If None, uses target_path.
Returns:
Number of files.
"""
target = Path(path) if path else self.target_path
if not target.exists():
return 0
if target.is_file():
return 1
count = 0
for file_info in self.scan_generator():
if not file_info.is_dir:
count += 1
return count
def find_large_files(
self,
min_size_mb: float = 10.0,
limit: int = 20,
) -> List[FileInfo]:
"""
Find large files in directory.
Args:
min_size_mb: Minimum file size in MB.
limit: Maximum number of files to return.
Returns:
List of large files, sorted by size (descending).
"""
min_size_bytes = int(min_size_mb * 1024 * 1024)
large_files = []
for file_info in self.scan_generator():
if not file_info.is_dir and file_info.size >= min_size_bytes:
large_files.append(file_info)
# Sort by size (descending)
large_files.sort(key=lambda f: f.size, reverse=True)
return large_files[:limit]
diskcleaner/core/smart_cleanup.py
"""
Smart cleanup engine integrating all core modules.
Combines scanner, classifier, duplicate finder, and safety checker
to provide intelligent cleanup recommendations.
"""
import time
from dataclasses import dataclass
from datetime import datetime
from pathlib import Path
from typing import Dict, List, Optional
from diskcleaner.config import Config
from diskcleaner.core.classifier import FileClassifier
from diskcleaner.core.duplicate_finder import DuplicateFinder, DuplicateGroup
from diskcleaner.core.safety import SafetyChecker
from diskcleaner.core.scanner import DirectoryScanner, FileInfo
@dataclass
class CleanupReport:
"""
Comprehensive cleanup analysis report.
Contains categorized cleanup recommendations with statistics.
"""
# Categorized files
by_type: Dict[str, List[FileInfo]]
by_risk: Dict[str, List[FileInfo]]
by_age: Dict[str, List[FileInfo]]
# Duplicate files
duplicates: List[DuplicateGroup]
# Statistics
total_files: int
total_size: int
reclaimable_space: int
# Scan metadata
scan_time: float
timestamp: float
@property
def safe_reclaimable(self) -> int:
"""Space that can be reclaimed from SAFE risk files."""
return sum(f.size for f in self.by_risk.get("safe", []))
@property
def confirm_reclaimable(self) -> int:
"""Space that can be reclaimed from CONFIRM_NEEDED risk files."""
return sum(f.size for f in self.by_risk.get("confirm_needed", []))
@property
def duplicate_reclaimable(self) -> int:
"""Space that can be reclaimed from duplicate files."""
return sum(d.reclaimable_space for d in self.duplicates)
@property
def total_reclaimable(self) -> int:
"""Total space that can be reclaimed."""
return self.safe_reclaimable + self.confirm_reclaimable + self.duplicate_reclaimable
class SmartCleanupEngine:
"""
Smart cleanup engine integrating all core modules.
Features:
- Incremental scanning with cache
- Three-dimensional classification (type, risk, age)
- Duplicate file detection with adaptive strategy
- Comprehensive safety checks
- Detailed cleanup reports
"""
def __init__(
self,
target_path: str,
config: Optional[Config] = None,
cache_enabled: bool = True,
):
"""
Initialize smart cleanup engine.
Args:
target_path: Path to analyze.
config: Configuration object.
cache_enabled: Enable incremental scanning with cache.
"""
self.target_path = Path(target_path).expanduser().resolve()
self.config = config or Config.load()
self.cache_enabled = cache_enabled
# Initialize core modules
self.scanner = DirectoryScanner(
str(self.target_path), config=self.config, cache_enabled=cache_enabled
)
self.classifier = FileClassifier(config=self.config)
self.duplicate_finder = DuplicateFinder(strategy="adaptive")
self.safety = SafetyChecker(config=self.config)
def analyze(
self,
include_duplicates: bool = True,
safety_check: bool = True,
) -> CleanupReport:
"""
Perform comprehensive cleanup analysis.
Args:
include_duplicates: Whether to detect duplicate files.
safety_check: Whether to perform safety checks.
Returns:
CleanupReport with categorized recommendations.
"""
start_time = time.time()
# Step 1: Scan directory (incremental if cache enabled)
if self.cache_enabled:
files, _new_files, _changed_files = self.scanner.scan_incremental()
else:
files = self.scanner.scan()
# Filter out directories
file_list = [f for f in files if not f.is_dir]
# Step 2: Three-dimensional classification
classification = self.classifier.classify(file_list)
# Step 3: Find duplicates (optional)
duplicates = []
if include_duplicates:
duplicates = self.duplicate_finder.find_duplicates(file_list)
# Step 4: Safety check (optional)
if safety_check:
# Check all files and mark safe/unsafe
safety_results = self.safety.verify_all(file_list)
# Filter out unsafe files from recommendations
safe_files = {
f.path for f, status in safety_results if status.value in ("safe", "confirm_needed")
}
# Filter classifications to only include safe files
for category in classification["by_type"]:
classification["by_type"][category] = [
f for f in classification["by_type"][category] if f.path in safe_files
]
for risk_level in classification["by_risk"]:
classification["by_risk"][risk_level] = [
f for f in classification["by_risk"][risk_level] if f.path in safe_files
]
for age_group in classification["by_age"]:
classification["by_age"][age_group] = [
f for f in classification["by_age"][age_group] if f.path in safe_files
]
# Filter duplicates to only include safe files
if duplicates:
safe_duplicates = []
for dup_group in duplicates:
safe_dup_files = [f for f in dup_group.files if f.path in safe_files]
if len(safe_dup_files) > 1:
# Create new duplicate group with only safe files
safe_duplicates.append(
DuplicateGroup(
files=safe_dup_files,
size=dup_group.size,
hash_value=dup_group.hash_value,
)
)
duplicates = safe_duplicates
# Step 5: Calculate statistics
total_files = len(file_list)
total_size = sum(f.size for f in file_list)
reclaimable_space = (
sum(f.size for f in classification["by_risk"].get("safe", []))
+ sum(f.size for f in classification["by_risk"].get("confirm_needed", []))
+ sum(d.reclaimable_space for d in duplicates)
)
scan_time = time.time() - start_time
# Step 6: Create report
report = CleanupReport(
by_type=classification["by_type"],
by_risk=classification["by_risk"],
by_age=classification["by_age"],
duplicates=duplicates,
total_files=total_files,
total_size=total_size,
reclaimable_space=reclaimable_space,
scan_time=scan_time,
timestamp=time.time(),
)
return report
def get_summary(self, report: CleanupReport) -> str:
"""
Get human-readable summary of cleanup report.
Args:
report: CleanupReport to summarize.
Returns:
Formatted summary string.
"""
lines = [
"=" * 60,
"磁盘清理分析报告",
"=" * 60,
f"扫描路径: {self.target_path}",
f"扫描时间: {datetime.fromtimestamp(report.timestamp).strftime('%Y-%m-%d %H:%M:%S')}",
f"耗时: {report.scan_time:.2f} 秒",
"",
"文件统计:",
f" 总文件数: {report.total_files:,}",
f" 总大小: {self._format_size(report.total_size)}",
"",
"可回收空间:",
" 安全删除: {} ({:,} 文件)".format(
self._format_size(report.safe_reclaimable),
len(report.by_risk.get("safe", [])),
),
" 需确认: {} ({:,} 文件)".format(
self._format_size(report.confirm_reclaimable),
len(report.by_risk.get("confirm_needed", [])),
),
" 重复文件: {} ({} 组)".format(
self._format_size(report.duplicate_reclaimable), len(report.duplicates)
),
" ————————————————",
" 总计可回收: {}".format(self._format_size(report.total_reclaimable)),
"",
]
# Add breakdown by type if any files found
if report.by_type:
lines.append("按类型分类:")
for file_type, type_files in sorted(
report.by_type.items(),
key=lambda x: sum(f.size for f in x[1]),
reverse=True,
):
if type_files:
total_size = sum(f.size for f in type_files)
size_str = self._format_size(total_size)
lines.append(" {}: {} 文件, {}".format(file_type, len(type_files), size_str))
# Add duplicate info if found
if report.duplicates:
lines.append("")
lines.append("重复文件组 (前5组):")
for i, dup in enumerate(report.duplicates[:5], 1):
lines.append(
f" {i}. {dup.count} 个重复文件, {self._format_size(dup.size)} 每个, "
f"可回收 {self._format_size(dup.reclaimable_space)}"
)
for j, file in enumerate(dup.files[:3], 1):
lines.append(f" {j}. {file.path}")
if len(dup.files) > 3:
lines.append(f" ... 还有 {len(dup.files) - 3} 个文件")
lines.append("")
lines.append(60 * "=")
return "\n".join(lines)
def _format_size(self, size_bytes: int) -> str:
"""
Format byte size to human-readable string.
Args:
size_bytes: Size in bytes.
Returns:
Formatted size string (e.g., "1.23 GB").
"""
for unit in ["B", "KB", "MB", "GB", "TB"]:
if size_bytes < 1024.0:
if unit == "B":
return f"{size_bytes:,} {unit}"
return f"{size_bytes:.2f} {unit}"
size_bytes /= 1024.0
return f"{size_bytes:.2f} PB"
def get_files_by_type(self, report: CleanupReport, file_type: str) -> List[FileInfo]:
"""
Get files of a specific type from report.
Args:
report: CleanupReport.
file_type: Type category name.
Returns:
List of FileInfo objects of that type.
"""
return report.by_type.get(file_type, [])
def get_files_by_risk(self, report: CleanupReport, risk_level: str) -> List[FileInfo]:
"""
Get files of a specific risk level from report.
Args:
report: CleanupReport.
risk_level: Risk level ('safe', 'confirm_needed', 'protected').
Returns:
List of FileInfo objects with that risk level.
"""
return report.by_risk.get(risk_level, [])
def get_files_by_age(self, report: CleanupReport, age_group: str) -> List[FileInfo]:
"""
Get files of a specific age group from report.
Args:
report: CleanupReport.
age_group: Age group name (e.g., "很旧 (90天以上)").
Returns:
List of FileInfo objects in that age group.
"""
return report.by_age.get(age_group, [])
diskcleaner/optimization/__init__.py
"""
Performance optimization module for disk-cleaner.
This module provides intelligent, layered performance optimizations:
- Concurrent scanning and deletion
- Incremental caching
- Adaptive hash computation
- Performance monitoring
All optimizations are pluggable and can be disabled via configuration.
"""
from diskcleaner.optimization.concurrency import ConcurrencyManager
from diskcleaner.optimization.delete import (
AsyncDeleter,
BatchDeleter,
DeleteResult,
DeleteStrategy,
DeletionManager,
ProgressUpdate,
SmartDeleter,
)
from diskcleaner.optimization.hash import (
AdaptiveHasher,
DuplicateFinder,
DuplicateGroup,
FastFilter,
HashCache,
ParallelHasher,
)
from diskcleaner.optimization.memory import MemoryMonitor, MemoryStatus
from diskcleaner.optimization.profiler import PerformanceProfiler, PerformanceReport
from diskcleaner.optimization.scan import (
ConcurrentScanner,
FileInfo,
IncrementalCache,
QuickProfiler,
ScanProfile,
ScanResult,
ScanSnapshot,
ScanStrategy,
)
__all__ = [
# Infrastructure
"PerformanceProfiler",
"PerformanceReport",
"ConcurrencyManager",
"MemoryMonitor",
"MemoryStatus",
# Scanning
"QuickProfiler",
"ConcurrentScanner",
"IncrementalCache",
"ScanStrategy",
"ScanProfile",
"ScanResult",
"ScanSnapshot",
"FileInfo",
# Deletion
"BatchDeleter",
"AsyncDeleter",
"SmartDeleter",
"DeletionManager",
"DeleteStrategy",
"DeleteResult",
"ProgressUpdate",
# Hash
"AdaptiveHasher",
"ParallelHasher",
"FastFilter",
"HashCache",
"DuplicateFinder",
"DuplicateGroup",
]
diskcleaner/optimization/concurrency.py
"""
Concurrency management for optimized execution.
Manages thread pools and process pools for concurrent operations.
Provides optimal worker count calculation and resource cleanup.
"""
import os
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
from typing import Dict, Optional
class ConcurrencyManager:
"""
Unified manager for concurrent resources.
Manages:
- Thread pools (for I/O-bound tasks)
- Process pools (for CPU-bound tasks)
- Optimal worker count calculation
- Graceful shutdown
"""
def __init__(self):
self.thread_pools: Dict[str, ThreadPoolExecutor] = {}
self.process_pools: Dict[str, ProcessPoolExecutor] = {}
self._initialized = False
def get_thread_pool(
self, purpose: str, max_workers: Optional[int] = None
) -> ThreadPoolExecutor:
"""
Get or create a thread pool.
Args:
purpose: Pool identifier ('io_scan', 'io_delete', 'ui_update')
max_workers: Maximum worker threads (None for auto)
Returns:
ThreadPoolExecutor instance
"""
if purpose in self.thread_pools:
return self.thread_pools[purpose]
workers = max_workers or self._optimal_threads(purpose)
pool = ThreadPoolExecutor(max_workers=workers, thread_name_prefix=f"{purpose}-")
self.thread_pools[purpose] = pool
self._initialized = True
return pool
def get_process_pool(
self, purpose: str, max_workers: Optional[int] = None
) -> ProcessPoolExecutor:
"""
Get or create a process pool.
Args:
purpose: Pool identifier ('hash_compute', 'cpu_intensive')
max_workers: Maximum worker processes (None for auto)
Returns:
ProcessPoolExecutor instance
"""
if purpose in self.process_pools:
return self.process_pools[purpose]
workers = max_workers or self._optimal_processes(purpose)
pool = ProcessPoolExecutor(max_workers=workers)
self.process_pools[purpose] = pool
self._initialized = True
return pool
def _optimal_threads(self, purpose: str) -> int:
"""
Calculate optimal thread count for a purpose.
I/O-bound tasks can use more threads than CPU count.
"""
cpu_count = os.cpu_count() or 1
if purpose.startswith("io_"):
# I/O密集型：可以用更多线程
# 限制在32以内，避免过多上下文切换
return min(32, cpu_count * 4)
elif purpose == "ui_update":
# UI更新只需要少量线程
return 2
else:
# 默认：CPU核心数
return cpu_count
def _optimal_processes(self, purpose: str) -> int:
"""
Calculate optimal process count for a purpose.
CPU-bound tasks should not exceed CPU count.
"""
cpu_count = os.cpu_count() or 1
if purpose == "hash_compute":
# 哈希计算是CPU密集型
return cpu_count
else:
# 默认
return cpu_count
def shutdown_pool(self, purpose: str, wait: bool = True):
"""
Shutdown a specific pool.
Args:
purpose: Pool identifier
wait: Whether to wait for pending work to complete
"""
if purpose in self.thread_pools:
self.thread_pools[purpose].shutdown(wait=wait)
del self.thread_pools[purpose]
if purpose in self.process_pools:
self.process_pools[purpose].shutdown(wait=wait)
del self.process_pools[purpose]
def shutdown_all(self, wait: bool = True):
"""
Shutdown all pools gracefully.
Args:
wait: Whether to wait for pending work to complete
"""
for pool in self.thread_pools.values():
pool.shutdown(wait=wait)
self.thread_pools.clear()
for pool in self.process_pools.values():
pool.shutdown(wait=wait)
self.process_pools.clear()
self._initialized = False
def get_pool_count(self) -> int:
"""Get total number of active pools."""
return len(self.thread_pools) + len(self.process_pools)
def is_initialized(self) -> bool:
"""Check if any pools have been created."""
return self._initialized
def __enter__(self):
"""Context manager entry."""
return self
def __exit__(self, exc_type, exc_val, exc_tb):
"""Context manager exit with cleanup."""
self.shutdown_all(wait=True)
return False
diskcleaner/optimization/delete.py
"""
Optimized deletion components.
Provides:
- BatchDeleter: Smart batched deletion
- AsyncDeleter: Background async deletion
- DeleteStrategy: Smart deletion strategy selection
"""
import os
import shutil
import threading
import time
from concurrent.futures import ThreadPoolExecutor, as_completed
from dataclasses import dataclass
from enum import Enum
from pathlib import Path
from typing import Any, Dict, Iterator, List, Optional, Tuple
class DeleteStrategy(Enum):
"""Deletion strategy types."""
DELETE_DIRECT = "direct" # Direct delete (fastest)
DELETE_RECYCLE = "recycle" # Move to recycle bin
DELETE_SMART = "smart" # Smart selection
@dataclass
class DeleteResult:
"""Result of a delete operation."""
success: List[Path]
failed: List[Path]
total_deleted: int
total_failed: int
total_size_freed: int
elapsed_time: float
cancelled: bool = False
def to_dict(self) -> Dict[str, Any]:
"""Convert to dictionary."""
return {
"success": [str(p) for p in self.success],
"failed": [str(p) for p in self.failed],
"total_deleted": self.total_deleted,
"total_failed": self.total_failed,
"total_size_freed": self.total_size_freed,
"elapsed_time": self.elapsed_time,
"cancelled": self.cancelled,
}
@dataclass
class ProgressUpdate:
"""Progress update for deletion operations."""
current: int
total: int
percent: float
batch: int
total_batches: int
current_file: Optional[str] = None
speed: float = 0.0 # files/second
def to_dict(self) -> Dict[str, Any]:
"""Convert to dictionary."""
return {
"current": self.current,
"total": self.total,
"percent": self.percent,
"batch": self.batch,
"total_batches": self.total_batches,
"current_file": self.current_file,
"speed": self.speed,
}
class BatchDeleter:
"""
Smart batched file deletion.
Deletes files in batches with progress tracking and error handling.
"""
def __init__(self, progress_callback=None):
"""
Initialize batch deleter.
Args:
progress_callback: Optional callback for progress updates
"""
self.batch_config = {
"small": {"count": 1000, "interval": 0.1},
"medium": {"count": 5000, "interval": 0.5},
"large": {"count": 10000, "interval": 1.0},
}
self.progress_callback = progress_callback
def delete_with_progress(self, files: List[Path]) -> DeleteResult:
"""
Delete files in batches with progress updates.
Args:
files: List of files to delete
Returns:
DeleteResult with success/failed files
"""
if not files:
return DeleteResult(
success=[],
failed=[],
total_deleted=0,
total_failed=0,
total_size_freed=0,
elapsed_time=0.0,
)
start_time = time.time()
# Select batch strategy
file_count = len(files)
if file_count < 5000:
config = self.batch_config["small"]
elif file_count < 20000:
config = self.batch_config["medium"]
else:
config = self.batch_config["large"]
batch_size = config["count"]
interval = config["interval"]
success = []
failed = []
cancelled = False
total_size = 0
# Process in batches
for i in range(0, file_count, batch_size):
if cancelled:
break
batch = files[i : i + batch_size]
batch_success, batch_failed, batch_size_freed = self._delete_batch(batch)
success.extend(batch_success)
failed.extend(batch_failed)
total_size += batch_size_freed
# Progress update
current_count = len(success) + len(failed)
if self.progress_callback:
progress = ProgressUpdate(
current=current_count,
total=file_count,
percent=(current_count / file_count) * 100,
batch=i // batch_size + 1,
total_batches=(file_count + batch_size - 1) // batch_size,
)
# Callback returns False to cancel
if self.progress_callback(progress) is False:
cancelled = True
break
# Batch interval (let system breathe)
if i + batch_size < file_count:
time.sleep(interval)
elapsed_time = time.time() - start_time
return DeleteResult(
success=success,
failed=failed,
total_deleted=len(success),
total_failed=len(failed),
total_size_freed=total_size,
elapsed_time=elapsed_time,
cancelled=cancelled,
)
def _delete_batch(self, files: List[Path]) -> Tuple[List[Path], List[Path], int]:
"""
Delete a batch of files.
Args:
files: Files to delete
Returns:
Tuple of (success_list, failed_list, size_freed)
"""
success = []
failed = []
size_freed = 0
for file in files:
try:
# Permission check (fast fail)
if not os.access(file, os.W_OK):
failed.append(file)
continue
# Get size before deletion
try:
file_size = file.stat().st_size
except OSError:
file_size = 0
# Delete based on type
if file.is_dir():
shutil.rmtree(file, ignore_errors=False)
else:
file.unlink()
success.append(file)
size_freed += file_size
except (PermissionError, OSError):
failed.append(file)
except Exception:
failed.append(file)
return success, failed, size_freed
class AsyncDeleter:
"""
Async file deletion with background execution.
Executes deletion in background threads while main thread handles UI.
"""
def __init__(self, max_workers: int = 2, progress_callback=None):
"""
Initialize async deleter.
Args:
max_workers: Number of worker threads (2 is optimal for I/O)
progress_callback: Optional callback for progress updates
"""
self.max_workers = max_workers
self.executor: Optional[ThreadPoolExecutor] = None
self.progress_callback = progress_callback
self.stop_event = threading.Event()
def delete_async(self, files: List[Path]) -> Iterator[ProgressUpdate]:
"""
Delete files asynchronously, yielding progress updates.
Args:
files: Files to delete
Yields:
ProgressUpdate objects with deletion progress
"""
if not files:
return
self.executor = ThreadPoolExecutor(max_workers=self.max_workers)
self.stop_event.clear()
# Split into batches
batch_size = 100
batches = [files[i : i + batch_size] for i in range(0, len(files), batch_size)]
# Submit all batches
futures = {}
for batch_id, batch in enumerate(batches):
if not self.stop_event.is_set():
future = self.executor.submit(self._delete_batch_async, batch_id, batch)
futures[future] = batch_id
# Collect results
total_deleted = 0
total_failed = 0
total_size = 0
start_time = time.time()
for future in as_completed(futures):
if self.stop_event.is_set():
future.cancel()
continue
try:
result = future.result(timeout=30.0)
total_deleted += result["deleted"]
total_failed += result["failed"]
total_size += result["size_freed"]
# Yield progress update
elapsed = time.time() - start_time
speed = total_deleted / elapsed if elapsed > 0 else 0
update = ProgressUpdate(
batch_id=futures[future],
current=total_deleted + total_failed,
total=len(files),
percent=((total_deleted + total_failed) / len(files)) * 100,
batch=futures[future] + 1,
total_batches=len(batches),
speed=speed,
)
if self.progress_callback:
self.progress_callback(update)
yield update
except Exception:
pass # Log error, continue
self.stop_event.clear()
# Cleanup executor
if self.executor:
self.executor.shutdown(wait=False)
self.executor = None
def _delete_batch_async(self, batch_id: int, files: List[Path]) -> Dict[str, int]:
"""
Worker thread: delete a batch of files.
Args:
batch_id: Batch identifier
files: Files to delete
Returns:
Dict with deletion statistics
"""
deleted = 0
failed = 0
size_freed = 0
for file in files:
if self.stop_event.is_set():
break
try:
# Get size before deletion
try:
file_size = file.stat().st_size
except OSError:
file_size = 0
# Delete
if file.is_dir():
shutil.rmtree(file)
else:
file.unlink()
deleted += 1
size_freed += file_size
except Exception:
failed += 1
return {
"batch_id": batch_id,
"deleted": deleted,
"failed": failed,
"size_freed": size_freed,
}
def cancel(self):
"""Cancel the deletion operation."""
self.stop_event.set()
def shutdown(self):
"""Cleanup resources."""
self.stop_event.set()
if self.executor:
self.executor.shutdown(wait=False)
self.executor = None
class SmartDeleter:
"""
Smart deletion with strategy selection.
Automatically chooses optimal deletion strategy based on file characteristics.
"""
def __init__(self, use_recycle_bin: bool = False, large_file_threshold: int = 50 * 1024 * 1024):
"""
Initialize smart deleter.
Args:
use_recycle_bin: Whether to use recycle bin (platform-dependent)
large_file_threshold: Size threshold for "large file" (default 50MB)
"""
self.use_recycle_bin = use_recycle_bin
self.large_file_threshold = large_file_threshold
def delete_file(self, file: Path) -> bool:
"""
Delete a single file using smart strategy.
Args:
file: File to delete
Returns:
True if successful, False otherwise
"""
try:
if not file.exists():
return False
# Check if should use recycle bin
if self.use_recycle_bin and self._should_use_recycle_bin(file):
return self._move_to_recycle_bin(file)
else:
# Direct delete
if file.is_dir():
shutil.rmtree(file)
else:
file.unlink()
return True
except Exception:
return False
def _should_use_recycle_bin(self, file: Path) -> bool:
"""
Decide if file should go to recycle bin.
Args:
file: File to check
Returns:
True if should use recycle bin
"""
# Large files go to recycle bin (unless user data)
if file.stat().st_size > self.large_file_threshold:
return True
# System paths go to recycle bin
path_str = str(file).lower()
system_indicators = ["windows", "program files", "system", "library"]
if any(indicator in path_str for indicator in system_indicators):
return True
# User data goes to recycle bin
user_indicators = ["users", "home", "documents", "desktop"]
if any(indicator in path_str for indicator in user_indicators):
return True
# Small temp files: direct delete
return False
def _move_to_recycle_bin(self, file: Path) -> bool:
"""
Move file to recycle bin.
Args:
file: File to move
Returns:
True if successful
"""
try:
# Platform-specific implementation
if os.name == "nt": # Windows
import send2trash
send2trash.send2trash(str(file))
return True
else: # macOS/Linux
# Try send2trash if available
try:
import send2trash
send2trash.send2trash(str(file))
return True
except ImportError:
# Fallback to direct delete
if file.is_dir():
shutil.rmtree(file)
else:
file.unlink()
return True
except Exception:
# Fallback to direct delete
try:
if file.is_dir():
shutil.rmtree(file)
else:
file.unlink()
return True
except Exception:
return False
class DeletionManager:
"""
High-level deletion manager.
Provides unified interface for all deletion strategies.
"""
def __init__(
self, strategy: DeleteStrategy = DeleteStrategy.DELETE_SMART, progress_callback=None
):
"""
Initialize deletion manager.
Args:
strategy: Deletion strategy to use
progress_callback: Optional progress callback
"""
self.strategy = strategy
self.progress_callback = progress_callback
self.batch_deleter = BatchDeleter(progress_callback)
self.async_deleter = None # Created when needed
self.smart_deleter = SmartDeleter()
def delete(self, files: List[Path], async_mode: bool = False) -> DeleteResult:
"""
Delete files using configured strategy.
Args:
files: Files to delete
async_mode: Whether to use async deletion
Returns:
DeleteResult with operation results
"""
if not files:
return DeleteResult(
success=[],
failed=[],
total_deleted=0,
total_failed=0,
total_size_freed=0,
elapsed_time=0.0,
)
if async_mode:
return self._delete_async(files)
else:
return self._delete_batch(files)
def _delete_batch(self, files: List[Path]) -> DeleteResult:
"""Delete files in batches."""
# Apply smart strategy filtering
if self.strategy == DeleteStrategy.DELETE_SMART:
files = self._apply_smart_filtering(files)
return self.batch_deleter.delete_with_progress(files)
def _delete_async(self, files: List[Path]) -> DeleteResult:
"""Delete files asynchronously."""
self.async_deleter = AsyncDeleter(progress_callback=self.progress_callback)
success = []
failed = []
total_size = 0
start_time = time.time()
# Collect results from async operation
for update in self.async_deleter.delete_async(files):
# Update is yielded, but we don't track individual file results here
pass
# For async mode, we'd need to track results differently
# This is a simplified version
elapsed_time = time.time() - start_time
return DeleteResult(
success=success, # Would be filled by actual implementation
failed=failed,
total_deleted=len(success),
total_failed=len(failed),
total_size_freed=total_size,
elapsed_time=elapsed_time,
)
def _apply_smart_filtering(self, files: List[Path]) -> List[Path]:
"""
Apply smart strategy filtering.
Args:
files: Files to filter
Returns:
Filtered file list
"""
# Smart strategy: separate files by deletion method
return files # Simplified, would filter in real implementation
def cancel(self):
"""Cancel ongoing deletion."""
if self.async_deleter:
self.async_deleter.cancel()
def shutdown(self):
"""Cleanup resources."""
if self.async_deleter:
self.async_deleter.shutdown()
diskcleaner/optimization/hash.py
"""
Optimized hash computation components.
Provides:
- AdaptiveHasher: Size-based adaptive hashing
- ParallelHasher: Concurrent hash computation
- FastFilter: Quick pre-filtering for duplicate detection
- HashCache: LRU cache for computed hashes
"""
import hashlib
import os
import threading
from collections import OrderedDict
from concurrent.futures import ProcessPoolExecutor, as_completed
from dataclasses import dataclass
from pathlib import Path
from typing import Callable, Dict, List, Optional, Tuple
from diskcleaner.optimization.scan import FileInfo
@dataclass
class DuplicateGroup:
"""Group of duplicate files."""
files: List[FileInfo]
size: int
count: int
hash_value: str
reclaimable_space: int
def to_dict(self) -> dict:
"""Convert to dictionary."""
return {
"files": [f.to_dict() for f in self.files],
"size": self.size,
"count": self.count,
"hash": self.hash_value,
"reclaimable": self.reclaimable_space,
}
class AdaptiveHasher:
"""
Adaptive hash computation based on file size.
Automatically selects optimal hashing strategy:
- Small files (< 1MB): Full hash
- Medium files (1-100MB): Sampled hash (head, middle, tail)
- Large files (> 100MB): Multi-segment sampling
"""
def __init__(self, algorithm: str = "auto", chunk_size: int = 1024 * 1024):
"""
Initialize adaptive hasher.
Args:
algorithm: Hash algorithm ('auto', 'sha256', 'xxhash')
chunk_size: Chunk size for reading (1MB default)
"""
self.algorithm = self._choose_algorithm(algorithm)
self.chunk_size = chunk_size
def compute_hash(self, file: Path) -> str:
"""
Compute hash using adaptive strategy.
Args:
file: File to hash
Returns:
Hexadecimal hash string
"""
if not file.exists() or not file.is_file():
return ""
try:
size = file.stat().st_size
# Choose strategy based on size
if size < 1 * 1024 * 1024: # < 1MB
return self._full_hash(file)
elif size < 100 * 1024 * 1024: # 1-100MB
return self._sample_hash(file, chunks=[0.0, 0.5, 1.0])
else: # > 100MB
return self._multi_sample_hash(file, chunks=10)
except (OSError, IOError):
return ""
def _full_hash(self, file: Path) -> str:
"""Compute full file hash."""
h = self.algorithm()
with open(file, "rb") as f:
# Use large chunk reading for efficiency
for chunk in iter(lambda: f.read(self.chunk_size), b""):
h.update(chunk)
return h.hexdigest()
def _sample_hash(self, file: Path, chunks: List[float]) -> str:
"""
Compute sampled hash from specific positions.
Args:
file: File to hash
chunks: List of chunk positions (0.0-1.0)
Returns:
Hexadecimal hash string
"""
h = self.algorithm()
size = file.stat().st_size
with open(file, "rb") as f:
for chunk_pos in chunks:
offset = int(size * chunk_pos)
f.seek(offset)
data = f.read(self.chunk_size)
h.update(data)
return h.hexdigest()
def _multi_sample_hash(self, file: Path, chunks: int) -> str:
"""
Compute hash from multiple segments.
Args:
file: File to hash
chunks: Number of segments
Returns:
Hexadecimal hash string
"""
h = self.algorithm()
size = file.stat().st_size
with open(file, "rb") as f:
for i in range(chunks):
offset = int(size * i / chunks)
f.seek(offset)
data = f.read(self.chunk_size)
h.update(data)
return h.hexdigest()
def _choose_algorithm(self, algorithm: str) -> Callable:
"""
Choose hash algorithm.
Args:
algorithm: Algorithm name
Returns:
Hash constructor function
"""
if algorithm == "auto":
# Try fastest available
try:
import xxhash
return xxhash.xxh3_128
except ImportError:
pass
try:
import blake3
return blake3.blake3
except ImportError:
pass
return hashlib.sha256
elif algorithm == "sha256":
return hashlib.sha256
elif algorithm == "xxhash":
try:
import xxhash
return xxhash.xxh3_128
except ImportError:
return hashlib.sha256
elif algorithm == "blake3":
try:
import blake3
return blake3.blake3
except ImportError:
return hashlib.sha256
else:
return hashlib.sha256
class ParallelHasher:
"""
Concurrent hash computation using process pool.
Optimized for CPU-bound hash computation.
"""
def __init__(self, max_workers: Optional[int] = None, algorithm: str = "auto"):
"""
Initialize parallel hasher.
Args:
max_workers: Number of worker processes (None = CPU count)
algorithm: Hash algorithm to use
"""
self.max_workers = max_workers or os.cpu_count()
self.algorithm = algorithm
self.executor: Optional[ProcessPoolExecutor] = None
def hash_files_parallel(self, files: List[Path], progress_callback=None) -> Dict[Path, str]:
"""
Compute hashes for multiple files in parallel.
Args:
files: Files to hash
progress_callback: Optional progress callback
Returns:
Dict mapping file paths to hash values
"""
if not files:
return {}
result: Dict[Path, str] = {}
self.executor = ProcessPoolExecutor(max_workers=self.max_workers)
# Submit all tasks
futures = {}
for file in files:
future = self.executor.submit(self._hash_single_file, str(file), self.algorithm)
futures[future] = file
# Collect results
completed = 0
for future in as_completed(futures):
file = futures[future]
try:
hash_value = future.result(timeout=60.0)
result[file] = hash_value
except Exception:
result[file] = "" # Mark as failed
completed += 1
if progress_callback:
progress_callback(
{
"current": completed,
"total": len(files),
"file": str(file),
}
)
# Cleanup
self.executor.shutdown(wait=True)
self.executor = None
return result
@staticmethod
def _hash_single_file(file_path: str, algorithm: str = "auto") -> str:
"""
Static method: Compute hash for a single file.
Runs in worker process.
Args:
file_path: Path to file
algorithm: Hash algorithm
Returns:
Hexadecimal hash string
"""
hasher = AdaptiveHasher(algorithm=algorithm)
return hasher.compute_hash(Path(file_path))
def shutdown(self):
"""Shutdown executor."""
if self.executor:
self.executor.shutdown(wait=False)
self.executor = None
class FastFilter:
"""
Fast pre-filtering for duplicate file detection.
Eliminates obvious non-duplicates before expensive hashing.
"""
def __init__(self):
"""Initialize fast filter."""
pass
def quick_dedup(self, files: List[FileInfo]) -> List[List[FileInfo]]:
"""
Quick pre-filtering using size grouping.
Args:
files: Files to filter
Returns:
List of file groups that might be duplicates
"""
# Group by size
by_size: Dict[int, List[FileInfo]] = {}
for file in files:
size = file.size
if size not in by_size:
by_size[size] = []
by_size[size].append(file)
# Only keep groups with multiple files
candidates = [group for group in by_size.values() if len(group) > 1]
return candidates
def filter_by_extension(
self, files: List[FileInfo], extensions: Optional[List[str]] = None
) -> List[FileInfo]:
"""
Filter files by extension.
Args:
files: Files to filter
extensions: List of extensions to keep (None = all)
Returns:
Filtered file list
"""
if extensions is None:
return files
ext_set = set(ext.lower() for ext in extensions)
return [f for f in files if Path(f.path).suffix.lower() in ext_set]
def filter_by_size(
self, files: List[FileInfo], min_size: int = 0, max_size: Optional[int] = None
) -> List[FileInfo]:
"""
Filter files by size range.
Args:
files: Files to filter
min_size: Minimum file size (bytes)
max_size: Maximum file size (None = no limit)
Returns:
Filtered file list
"""
result = [f for f in files if f.size >= min_size]
if max_size is not None:
result = [f for f in result if f.size <= max_size]
return result
class HashCache:
"""
LRU cache for computed hash values.
Reduces redundant hash computations.
"""
def __init__(self, max_size: int = 10000):
"""
Initialize hash cache.
Args:
max_size: Maximum number of cached entries
"""
self.cache: OrderedDict[Tuple[str, int, float], str] = OrderedDict()
self.max_size = max_size
self.lock = threading.Lock()
self.hits = 0
self.misses = 0
def get_or_compute(self, file: Path, compute_func: Optional[Callable] = None) -> Optional[str]:
"""
Get cached hash or compute if not cached.
Args:
file: File to get hash for
compute_func: Optional function to compute hash if not cached
Returns:
Hash string, or None if not cached and no compute_func provided
"""
try:
stat = file.stat()
key = (str(file), stat.st_size, stat.st_mtime)
except OSError:
if compute_func:
return compute_func(file)
return None
with self.lock:
# Check cache
if key in self.cache:
self.hits += 1
# Move to end (most recently used)
self.cache.move_to_end(key)
return self.cache[key]
self.misses += 1
# Compute if function provided
if compute_func:
hash_value = compute_func(file)
if hash_value:
# Add to cache
self.cache[key] = hash_value
self.cache.move_to_end(key)
# Evict oldest if over limit
if len(self.cache) > self.max_size:
self.cache.popitem(last=False)
return hash_value
return None
def get(self, file: Path) -> Optional[str]:
"""
Get cached hash without computing.
Args:
file: File to get hash for
Returns:
Cached hash string, or None if not cached
"""
try:
stat = file.stat()
key = (str(file), stat.st_size, stat.st_mtime)
except OSError:
return None
with self.lock:
if key in self.cache:
self.hits += 1
self.cache.move_to_end(key)
return self.cache[key]
else:
self.misses += 1
return None
def put(self, file: Path, hash_value: str) -> None:
"""
Add hash to cache.
Args:
file: File path
hash_value: Hash value to cache
"""
try:
stat = file.stat()
key = (str(file), stat.st_size, stat.st_mtime)
except OSError:
return
with self.lock:
self.cache[key] = hash_value
self.cache.move_to_end(key)
# Evict oldest if over limit
if len(self.cache) > self.max_size:
self.cache.popitem(last=False)
def invalidate(self, file: Path) -> None:
"""
Invalidate cached hash for a file.
Args:
file: File to invalidate
"""
try:
stat = file.stat()
key = (str(file), stat.st_size, stat.st_mtime)
except OSError:
return
with self.lock:
if key in self.cache:
del self.cache[key]
def clear(self) -> None:
"""Clear all cached entries."""
with self.lock:
self.cache.clear()
self.hits = 0
self.misses = 0
def get_stats(self) -> Dict[str, int]:
"""
Get cache statistics.
Returns:
Dict with cache stats
"""
with self.lock:
total = self.hits + self.misses
hit_rate = self.hits / total if total > 0 else 0
return {
"size": len(self.cache),
"max_size": self.max_size,
"hits": self.hits,
"misses": self.misses,
"hit_rate": int(hit_rate * 100), # percentage
}
class DuplicateFinder:
"""
High-level duplicate file finder.
Combines all optimization components for efficient duplicate detection.
"""
def __init__(self, use_parallel: bool = True, use_cache: bool = True, algorithm: str = "auto"):
"""
Initialize duplicate finder.
Args:
use_parallel: Whether to use parallel hashing
use_cache: Whether to use hash caching
algorithm: Hash algorithm to use
"""
self.use_parallel = use_parallel
self.use_cache = use_cache
self.algorithm = algorithm
self.hasher = AdaptiveHasher(algorithm=algorithm)
self.parallel_hasher: Optional[ParallelHasher] = None
self.cache: Optional[HashCache] = None
self.filter = FastFilter()
if use_parallel:
self.parallel_hasher = ParallelHasher(algorithm=algorithm)
if use_cache:
self.cache = HashCache()
def find_duplicates(
self, files: List[FileInfo], progress_callback=None
) -> List[DuplicateGroup]:
"""
Find duplicate files using adaptive strategy.
Args:
files: Files to check
progress_callback: Optional progress callback
Returns:
List of duplicate groups, sorted by reclaimable space
"""
if not files:
return []
# Step 1: Fast pre-filtering
if progress_callback:
progress_callback({"stage": "filtering", "message": "Quick pre-filtering"})
candidates = self.filter.quick_dedup(files)
if not candidates:
return []
# Flatten candidates for hashing
files_to_hash = []
for group in candidates:
files_to_hash.extend(group)
# Step 2: Compute hashes
if progress_callback:
progress_callback({"stage": "hashing", "message": "Computing hashes"})
if self.use_parallel and len(files_to_hash) > 10:
hashes = self._hash_parallel(files_to_hash, progress_callback)
else:
hashes = self._hash_sequential(files_to_hash, progress_callback)
# Step 3: Group by hash
hash_groups: Dict[str, List[FileInfo]] = {}
for file in files_to_hash:
hash_value = hashes.get(file.path, "")
if not hash_value:
continue
if hash_value not in hash_groups:
hash_groups[hash_value] = []
hash_groups[hash_value].append(file)
# Step 4: Create duplicate groups (only actual duplicates)
duplicates = []
for hash_value, group in hash_groups.items():
if len(group) > 1: # Only if multiple files have same hash
size = group[0].size
duplicates.append(
DuplicateGroup(
files=group,
size=size,
count=len(group),
hash_value=hash_value,
reclaimable_space=size * (len(group) - 1),
)
)
# Sort by reclaimable space (descending)
duplicates.sort(key=lambda d: d.reclaimable_space, reverse=True)
return duplicates
def _hash_sequential(self, files: List[FileInfo], progress_callback=None) -> Dict[str, str]:
"""Compute hashes sequentially."""
hashes = {}
for i, file_info in enumerate(files):
file = Path(file_info.path)
if self.cache:
hash_value = self.cache.get_or_compute(file, self.hasher.compute_hash)
else:
hash_value = self.hasher.compute_hash(file)
hashes[file_info.path] = hash_value
if progress_callback and i % 10 == 0:
progress_callback(
{
"current": i,
"total": len(files),
}
)
return hashes
def _hash_parallel(self, files: List[FileInfo], progress_callback=None) -> Dict[str, str]:
"""Compute hashes in parallel."""
file_paths = [Path(f.path) for f in files]
hashes = self.parallel_hasher.hash_files_parallel(file_paths, progress_callback)
return hashes
def get_cache_stats(self) -> Optional[Dict[str, int]]:
"""Get cache statistics if caching is enabled."""
if self.cache:
return self.cache.get_stats()
return None
def clear_cache(self) -> None:
"""Clear hash cache if caching is enabled."""
if self.cache:
self.cache.clear()
def shutdown(self) -> None:
"""Cleanup resources."""
if self.parallel_hasher:
self.parallel_hasher.shutdown()
diskcleaner/optimization/memory.py
"""
Memory monitoring and management.
Monitors memory usage and provides suggestions to prevent OOM.
"""
import gc
import os
from dataclasses import dataclass
from enum import Enum
class MemoryStatus(Enum):
"""Memory usage status."""
OK = "OK"
WARNING = "WARNING"
CRITICAL = "CRITICAL"
@dataclass
class MemoryInfo:
"""Current memory information."""
status: MemoryStatus
current_mb: float
threshold_mb: float
percent_used: float
suggestion: str
class MemoryMonitor:
"""
Memory usage monitor.
Features:
- Real-time memory tracking
- Automatic garbage collection trigger
- Dynamic concurrency adjustment suggestions
"""
def __init__(self, threshold_mb: int = 500):
"""
Initialize memory monitor.
Args:
threshold_mb: Memory threshold in MB
"""
self.threshold = threshold_mb * 1024 * 1024 # Convert to bytes
self.warning_threshold = self.threshold * 0.7
self.critical_threshold = self.threshold * 0.9
self.warning_shown = False
def get_memory_usage(self) -> float:
"""
Get current memory usage in bytes.
Returns:
Memory usage in bytes
"""
try:
import psutil
process = psutil.Process(os.getpid())
return process.memory_info().rss
except ImportError:
# Fallback: use tracemalloc
import tracemalloc
if not tracemalloc.is_tracing():
tracemalloc.start()
current, _ = tracemalloc.get_traced_memory()
return current
def check_memory(self) -> MemoryStatus:
"""
Check current memory usage status.
Returns:
MemoryStatus enum value
"""
current = self.get_memory_usage()
if current > self.critical_threshold:
return MemoryStatus.CRITICAL
elif current > self.warning_threshold:
return MemoryStatus.WARNING
else:
return MemoryStatus.OK
def get_memory_info(self) -> MemoryInfo:
"""
Get detailed memory information.
Returns:
MemoryInfo with current status and suggestion
"""
current_bytes = self.get_memory_usage()
current_mb = current_bytes / 1024 / 1024
threshold_mb = self.threshold / 1024 / 1024
percent_used = (current_bytes / self.threshold) * 100
status = self.check_memory()
suggestion = self._suggest_action(status)
return MemoryInfo(
status=status,
current_mb=current_mb,
threshold_mb=threshold_mb,
percent_used=percent_used,
suggestion=suggestion,
)
def _suggest_action(self, status: MemoryStatus) -> str:
"""
Suggest action based on memory status.
Returns:
Action suggestion string
"""
if status == MemoryStatus.CRITICAL:
return "STOP_AND_GC"
elif status == MemoryStatus.WARNING:
return "REDUCE_CONCURRENCY"
else:
return "CONTINUE"
def should_pause(self) -> bool:
"""
Check if operations should pause due to memory.
Returns:
True if memory usage is critical
"""
return self.check_memory() == MemoryStatus.CRITICAL
def should_reduce_concurrency(self) -> bool:
"""
Check if concurrency should be reduced.
Returns:
True if memory usage is at warning level
"""
status = self.check_memory()
return status == MemoryStatus.WARNING or status == MemoryStatus.CRITICAL
def force_gc(self) -> float:
"""
Force garbage collection and return freed memory.
Returns:
Memory freed in MB
"""
before = self.get_memory_usage()
gc.collect()
after = self.get_memory_usage()
freed_mb = (before - after) / 1024 / 1024
return freed_mb
def get_optimal_workers(self, current_workers: int) -> int:
"""
Adjust worker count based on memory pressure.
Args:
current_workers: Current number of workers
Returns:
Recommended worker count
"""
status = self.check_memory()
if status == MemoryStatus.CRITICAL:
# Reduce to minimum
return max(1, current_workers // 4)
elif status == MemoryStatus.WARNING:
# Reduce by half
return max(1, current_workers // 2)
else:
# No change needed
return current_workers
def format_memory(self, bytes_value: float) -> str:
"""
Format bytes to human-readable string.
Args:
bytes_value: Memory in bytes
Returns:
Formatted string (e.g., "128.5 MB")
"""
mb = bytes_value / 1024 / 1024
if mb < 1024:
return f"{mb:.1f} MB"
else:
gb = mb / 1024
return f"{gb:.2f} GB"
def summary(self) -> str:
"""Generate a summary of current memory status."""
info = self.get_memory_info()
lines = [
f"Memory Status: {info.status.value}",
(
f"Usage: {info.current_mb:.1f} MB / "
f"{info.threshold_mb:.0f} MB ({info.percent_used:.1f}%)"
),
f"Suggestion: {info.suggestion}",
]
return "\n".join(lines)
def set_threshold(self, threshold_mb: int):
"""
Update memory threshold.
Args:
threshold_mb: New threshold in MB
"""
self.threshold = threshold_mb * 1024 * 1024
self.warning_threshold = self.threshold * 0.7
self.critical_threshold = self.threshold * 0.9
diskcleaner/optimization/profiler.py
"""
Performance profiling and monitoring.
Tracks performance metrics for different operations to identify bottlenecks
and measure optimization effectiveness.
"""
import time
from contextlib import contextmanager
from dataclasses import dataclass
from typing import Dict, List, Optional
@dataclass
class PerformanceReport:
"""Performance report for an operation or session."""
operation: str
total_time: float
memory_used: float # MB
item_count: int
throughput: float # items/second
def __str__(self) -> str:
return (
f"{self.operation}: {self.total_time:.2f}s, "
f"{self.throughput:.0f} items/s, "
f"{self.memory_used:.1f} MB"
)
class PerformanceProfiler:
"""
Performance profiler for tracking operation metrics.
Measures:
- Execution time
- Memory usage
- Throughput (items per second)
- Identifies bottlenecks
"""
def __init__(self):
self.metrics: Dict[str, List[float]] = {}
self._operation_stack: List[str] = []
self._operation_times: Dict[str, float] = {}
@contextmanager
def profile(self, operation: str):
"""
Context manager for automatic performance recording.
Usage:
with profiler.profile('scan'):
result = scanner.scan()
"""
import tracemalloc
# Start tracking
start_time = time.time()
tracemalloc.start()
start_mem = tracemalloc.get_traced_memory()[0]
self._operation_stack.append(operation)
try:
yield
finally:
# Stop tracking
elapsed = time.time() - start_time
current_mem, peak_mem = tracemalloc.get_traced_memory()
tracemalloc.stop()
memory_used = (peak_mem - start_mem) / 1024 / 1024 # Convert to MB
# Record metrics (initialize list if needed)
time_key = f"{operation}_time"
mem_key = f"{operation}_memory"
if time_key not in self.metrics:
self.metrics[time_key] = []
if mem_key not in self.metrics:
self.metrics[mem_key] = []
self.metrics[time_key].append(elapsed)
self.metrics[mem_key].append(memory_used)
self._operation_times[operation] = elapsed
self._operation_stack.pop()
def record(self, operation: str, value: float, metric: str = "time"):
"""
Manually record a metric.
Args:
operation: Operation name (e.g., 'scan', 'delete')
value: Metric value
metric: Metric type ('time', 'memory', 'throughput')
"""
key = f"{operation}_{metric}"
if key not in self.metrics:
self.metrics[key] = []
self.metrics[key].append(value)
def get_operation_time(self, operation: str) -> Optional[float]:
"""Get the last recorded time for an operation."""
return self._operation_times.get(operation)
def get_average_time(self, operation: str) -> float:
"""Get average execution time for an operation."""
times = self.metrics.get(f"{operation}_time", [])
if not times:
return 0.0
return sum(times) / len(times)
def get_peak_memory(self, operation: str) -> float:
"""Get peak memory usage for an operation (MB)."""
memories = self.metrics.get(f"{operation}_memory", [])
if not memories:
return 0.0
return max(memories)
def generate_report(self, operation: str, item_count: int) -> PerformanceReport:
"""
Generate a performance report for an operation.
Args:
operation: Operation name
item_count: Number of items processed
Returns:
PerformanceReport with metrics
"""
total_time = self.get_average_time(operation)
memory_used = self.get_peak_memory(operation)
throughput = item_count / total_time if total_time > 0 else 0
return PerformanceReport(
operation=operation,
total_time=total_time,
memory_used=memory_used,
item_count=item_count,
throughput=throughput,
)
def get_all_reports(self) -> List[PerformanceReport]:
"""Get reports for all tracked operations."""
reports = []
for key in self.metrics.keys():
if key.endswith("_time"):
operation = key[:-5] # Remove '_time' suffix
if self.metrics[key]: # Only if has data
item_count = int(self.get_average_time(operation) * 1000) # Estimate
reports.append(self.generate_report(operation, item_count))
return reports
def identify_bottleneck(self) -> Optional[str]:
"""
Identify the slowest operation.
Returns:
Operation name with highest average time, or None
"""
operation_times = {}
for key, times in self.metrics.items():
if key.endswith("_time") and times:
operation = key[:-5]
avg_time = sum(times) / len(times)
operation_times[operation] = avg_time
if not operation_times:
return None
return max(operation_times.items(), key=lambda x: x[1])[0]
def reset(self):
"""Clear all metrics."""
self.metrics.clear()
self._operation_stack.clear()
self._operation_times.clear()
def summary(self) -> str:
"""Generate a summary of all metrics."""
lines = ["Performance Summary:", "=" * 50]
for operation in ["scan", "delete", "hash"]:
if self.metrics.get(f"{operation}_time"):
avg_time = self.get_average_time(operation)
peak_mem = self.get_peak_memory(operation)
lines.append(
f"{operation.capitalize()}: " f"{avg_time:.2f}s avg, " f"{peak_mem:.1f} MB peak"
)
bottleneck = self.identify_bottleneck()
if bottleneck:
lines.append(f"\nBottleneck: {bottleneck}")
return "\n".join(lines)
diskcleaner/optimization/scan.py
"""
Optimized scanning components.
Provides:
- QuickProfiler: Fast scene analysis
- ConcurrentScanner: Multi-threaded directory scanning
- IncrementalCache: Scan result caching
"""
import hashlib
import json
import os
import queue
import threading
import time
from dataclasses import asdict, dataclass
from pathlib import Path
from typing import Any, Dict, List, Optional
from diskcleaner.optimization.memory import MemoryMonitor
# Re-export for convenience
Empty = queue.Empty
Queue = queue.Queue
Full = queue.Full
@dataclass
class ScanProfile:
"""Profile of a scanning scene."""
file_count: int = 0
total_size: int = 0
dir_count: int = 0
max_depth: int = 0
avg_file_size: float = 0.0
files_per_second: float = 0.0
estimated_time: float = 0.0
def to_dict(self) -> Dict[str, Any]:
"""Convert to dictionary."""
return asdict(self)
@dataclass
class FileInfo:
"""Information about a file or directory."""
path: str
name: str
size: int
mtime: float
is_dir: bool = False
depth: int = 0
def to_dict(self) -> Dict[str, Any]:
"""Convert to dictionary."""
return asdict(self)
@classmethod
def from_dict(cls, data: Dict[str, Any]) -> "FileInfo":
"""Create from dictionary."""
return cls(**data)
@dataclass
class ScanResult:
"""Result of a scan operation."""
items: List[FileInfo]
total_count: int
total_size: int
error_count: int = 0
scan_time: float = 0.0
stopped_early: bool = False
stop_reason: str = ""
def to_dict(self) -> Dict[str, Any]:
"""Convert to dictionary."""
return {
"items": [item.to_dict() for item in self.items],
"total_count": self.total_count,
"total_size": self.total_size,
"error_count": self.error_count,
"scan_time": self.scan_time,
"stopped_early": self.stopped_early,
"stop_reason": self.stop_reason,
}
@dataclass
class ScanSnapshot:
"""Snapshot of a scan for caching."""
path: str
timestamp: float
items: List[FileInfo]
total_count: int
total_size: int
def to_dict(self) -> Dict[str, Any]:
"""Convert to dictionary."""
return {
"path": self.path,
"timestamp": self.timestamp,
"items": [item.to_dict() for item in self.items],
"total_count": self.total_count,
"total_size": self.total_size,
}
@classmethod
def from_dict(cls, data: Dict[str, Any]) -> "ScanSnapshot":
"""Create from dictionary."""
data["items"] = [FileInfo.from_dict(item) for item in data["items"]]
return cls(**data)
class QuickProfiler:
"""
Fast scene profiler for scanning strategy selection.
Performs short sampling to infer directory characteristics.
"""
def __init__(self, sample_time: float = 0.5):
"""
Initialize profiler.
Args:
sample_time: Sampling time in seconds
"""
self.sample_time = sample_time
def profile(self, path: Path) -> ScanProfile:
"""
Profile a directory by sampling.
Args:
path: Directory to profile
Returns:
ScanProfile with inferred characteristics
"""
if not path.exists():
return ScanProfile()
result = ScanProfile()
stop_flag = threading.Event()
profile_data = {
"file_count": 0,
"total_size": 0,
"dir_count": 0,
"max_depth": 0,
"sampled_files": 0,
}
lock = threading.Lock()
def scan_worker():
"""Background scanning thread."""
try:
for root, dirs, files in os.walk(str(path)):
if stop_flag.is_set():
break
with lock:
profile_data["dir_count"] += len(dirs)
profile_data["file_count"] += len(files)
# Sample file sizes (first 100)
for i, f in enumerate(files[:100]):
try:
file_path = Path(root) / f
if file_path.is_file():
profile_data["total_size"] += file_path.stat().st_size
profile_data["sampled_files"] += 1
except (OSError, PermissionError):
pass
# Calculate depth
depth = root[len(str(path)) :].count(os.sep)
profile_data["max_depth"] = max(profile_data["max_depth"], depth)
except Exception:
pass # Errors don't prevent sampling
# Start sampling thread
thread = threading.Thread(target=scan_worker, daemon=True)
thread.start()
thread.join(timeout=self.sample_time)
stop_flag.set()
# Calculate derived metrics
result.file_count = profile_data["file_count"]
result.total_size = profile_data["total_size"]
result.dir_count = profile_data["dir_count"]
result.max_depth = profile_data["max_depth"]
if profile_data["sampled_files"] > 0:
result.avg_file_size = profile_data["total_size"] / profile_data["sampled_files"]
if self.sample_time > 0:
result.files_per_second = result.file_count / self.sample_time
# Estimate full scan time (with 2x safety margin)
if result.files_per_second > 0:
result.estimated_time = (result.file_count / result.files_per_second) * 2
return result
class ConcurrentScanner:
"""
Concurrent directory scanner with bounded queues.
Uses thread pool for concurrent I/O operations.
"""
def __init__(
self,
max_workers: Optional[int] = None,
strategy: Optional["ScanStrategy"] = None,
memory_monitor: Optional[MemoryMonitor] = None,
progress_callback=None,
):
"""
Initialize concurrent scanner.
Args:
max_workers: Maximum worker threads (None for auto)
strategy: Scanning strategy options
memory_monitor: Memory monitoring instance
progress_callback: Optional callback for progress updates
"""
self.max_workers = max_workers or self._optimal_workers()
self.strategy = strategy or ScanStrategy()
self.memory_monitor = memory_monitor
self.progress_callback = progress_callback
# Bounded queue to prevent memory explosion
self.queue_size = 10000
def scan(self, path: Path, progress_callback=None) -> ScanResult:
"""
Concurrently scan a directory.
Args:
path: Directory to scan
progress_callback: Optional progress callback
Returns:
ScanResult with all found items
"""
if not path.exists() or not path.is_dir():
return ScanResult(items=[], total_count=0, total_size=0)
results = []
work_queue = Queue(maxsize=self.queue_size)
stop_event = threading.Event()
result_lock = threading.Lock()
callback = progress_callback or self.progress_callback
# Statistics
stats = {"count": 0, "errors": 0, "size": 0}
def worker(thread_id: int):
"""Worker thread: process directories from queue."""
while not stop_event.is_set():
try:
dir_path = work_queue.get(timeout=0.1)
except Empty:
continue
# Check memory
if self.memory_monitor and self.memory_monitor.should_pause():
stop_event.set()
break
# Scan single directory
try:
with os.scandir(dir_path) as entries:
dir_entries = []
for entry in entries:
if stop_event.is_set():
break
try:
stat = entry.stat()
item = FileInfo(
path=entry.path,
name=entry.name,
size=stat.st_size,
mtime=stat.st_mtime,
is_dir=entry.is_dir(follow_symlinks=False),
)
with result_lock:
results.append(item)
stats["count"] += 1
stats["size"] += item.size
# Add subdirectories to work queue
if entry.is_dir(follow_symlinks=False):
if not self.strategy.should_exclude(entry.path):
dir_entries.append(entry.path)
except (OSError, PermissionError):
with result_lock:
stats["errors"] += 1
continue
# Add subdirectories to queue
for subdir in dir_entries:
try:
work_queue.put(subdir, timeout=1.0)
except queue.Full:
# Queue full, stop scanning
stop_event.set()
except Exception:
pass
finally:
work_queue.task_done()
# Progress callback
if callback and stats["count"] % 100 == 0:
callback(
{
"count": stats["count"],
"errors": stats["errors"],
"size": stats["size"],
}
)
# Start worker threads
workers = [
threading.Thread(target=worker, args=(i,), daemon=True) for i in range(self.max_workers)
]
for w in workers:
w.start()
# Main thread: scan top level and seed queue
start_time = time.time()
try:
with os.scandir(str(path)) as entries:
for entry in entries:
if stop_event.is_set():
break
try:
stat = entry.stat()
item = FileInfo(
path=entry.path,
name=entry.name,
size=stat.st_size,
mtime=stat.st_mtime,
is_dir=entry.is_dir(follow_symlinks=False),
)
with result_lock:
results.append(item)
stats["count"] += 1
stats["size"] += item.size
# Add directory to work queue
if entry.is_dir(follow_symlinks=False):
if not self.strategy.should_exclude(entry.path):
work_queue.put(entry.path)
except (OSError, PermissionError):
stats["errors"] += 1
continue
# Wait for all work to complete
work_queue.join()
stop_event.set()
# Wait for workers to finish
for w in workers:
w.join(timeout=5.0)
except Exception:
stop_event.set()
scan_time = time.time() - start_time
return ScanResult(
items=results,
total_count=stats["count"],
total_size=stats["size"],
error_count=stats["errors"],
scan_time=scan_time,
stopped_early=stop_event.is_set(),
)
def _optimal_workers(self) -> int:
"""Calculate optimal worker thread count."""
cpu_count = os.cpu_count() or 1
# I/O bound, can use more threads
return min(32, cpu_count * 4)
class ScanStrategy:
"""
Scanning strategy configuration.
Defines which optimizations to apply.
"""
# Default exclude patterns
DEFAULT_EXCLUDES = [
# Windows
"C:\\Windows",
"C:\\Program Files",
"C:\\Program Files (x86)",
"C:\\ProgramData",
# macOS
"/System",
"/Library",
"/.Spotlight-V100",
"/.fseventsd",
"/.vol",
"/private/var/vm",
# Linux
"/proc",
"/sys",
"/dev",
"/run",
"/boot",
]
def __init__(self):
"""Initialize with default strategy."""
self.concurrent = True
self.cache_enabled = True
self.early_stop = False
self.max_files = 50000
self.max_time = 25 # seconds
self.excludes = list(self.DEFAULT_EXCLUDES)
def should_exclude(self, path: str) -> bool:
"""
Check if path should be excluded.
Args:
path: Path to check
Returns:
True if path should be excluded
"""
path_normalized = os.path.normpath(path)
for exclude in self.excludes:
if path_normalized.startswith(exclude):
return True
return False
def should_stop_early(self, current_count: int, elapsed_time: float) -> bool:
"""
Check if scanning should stop early.
Args:
current_count: Number of items scanned
elapsed_time: Time elapsed in seconds
Returns:
True if should stop
"""
if not self.early_stop:
return False
if current_count >= self.max_files:
return True
if elapsed_time >= self.max_time:
return True
return False
class IncrementalCache:
"""
Incremental scan cache.
Caches scan results to speed up repeat scans.
"""
def __init__(self, cache_dir: Optional[Path] = None, ttl_days: int = 7):
"""
Initialize cache.
Args:
cache_dir: Cache directory path (None for default)
ttl_days: Time-to-live for cache entries in days
"""
self.cache_dir = cache_dir or Path.home() / ".disk-cleaner" / "cache"
self.cache_dir.mkdir(parents=True, exist_ok=True)
self.ttl = ttl_days * 24 * 3600 # Convert to seconds
self._memory_cache: Dict[str, ScanSnapshot] = {}
def _get_cache_path(self, path: str) -> Path:
"""Get cache file path for a directory."""
# Use hash of path as cache key
path_hash = hashlib.md5(str(path).encode()).hexdigest()
return self.cache_dir / f"{path_hash}.json"
def get_cached_snapshot(self, path: Path) -> Optional[ScanSnapshot]:
"""
Get cached snapshot if available and valid.
Args:
path: Directory path
Returns:
ScanSnapshot if cached and valid, None otherwise
"""
# Check memory cache first
cache_key = str(path)
if cache_key in self._memory_cache:
snapshot = self._memory_cache[cache_key]
if self._is_valid(snapshot):
return snapshot
else:
del self._memory_cache[cache_key]
# Check disk cache
cache_file = self._get_cache_path(str(path))
if not cache_file.exists():
return None
try:
with open(cache_file, "r") as f:
data = json.load(f)
snapshot = ScanSnapshot.from_dict(data)
if not self._is_valid(snapshot):
cache_file.unlink() # Remove expired cache
return None
# Store in memory cache
self._memory_cache[cache_key] = snapshot
return snapshot
except (json.JSONDecodeError, KeyError, IOError):
return None
def save_snapshot(self, path: Path, snapshot: ScanSnapshot) -> None:
"""
Save a snapshot to cache.
Args:
path: Directory path
snapshot: Snapshot to save
"""
cache_key = str(path)
# Store in memory
self._memory_cache[cache_key] = snapshot
# Store on disk
cache_file = self._get_cache_path(str(path))
try:
with open(cache_file, "w") as f:
json.dump(snapshot.to_dict(), f)
except IOError:
pass # Fail silently
def _is_valid(self, snapshot: ScanSnapshot) -> bool:
"""Check if snapshot is still valid."""
age = time.time() - snapshot.timestamp
return age < self.ttl
def invalidate(self, path: Path) -> None:
"""
Invalidate cache for a path.
Args:
path: Directory path to invalidate
"""
cache_key = str(path)
# Remove from memory
if cache_key in self._memory_cache:
del self._memory_cache[cache_key]
# Remove from disk
cache_file = self._get_cache_path(str(path))
if cache_file.exists():
cache_file.unlink()
def clear_all(self) -> None:
"""Clear all cache."""
self._memory_cache.clear()
# Clear disk cache
for cache_file in self.cache_dir.glob("*.json"):
cache_file.unlink()
def get_cache_size(self) -> int:
"""Get total cache size in bytes."""
size = 0
for cache_file in self.cache_dir.glob("*.json"):
size += cache_file.stat().st_size
return size
diskcleaner/platforms/__init__.py
"""
Platform-specific functionality
"""
from diskcleaner.platforms.linux import LinuxPlatform
from diskcleaner.platforms.macos import MacOSPlatform
from diskcleaner.platforms.windows import WindowsPlatform
__all__ = [
"WindowsPlatform",
"LinuxPlatform",
"MacOSPlatform",
]
diskcleaner/platforms/linux.py
"""
Linux-specific platform functionality.
Provides Linux-specific temporary files, caches, and system cleanup locations.
"""
import os
from typing import Dict, List
class LinuxPlatform:
"""Linux platform-specific operations."""
@staticmethod
def get_temp_locations() -> List[str]:
"""Get Linux temporary file locations."""
locations = ["/tmp", "/var/tmp"]
# User-specific temp
user_cache = os.path.expanduser("~/.cache")
if os.path.exists(user_cache):
locations.append(user_cache)
return [loc for loc in locations if os.path.exists(loc)]
@staticmethod
def get_cache_locations() -> List[str]:
"""Get Linux cache locations."""
locations = ["/var/cache"]
# User cache
user_cache = os.path.expanduser("~/.cache")
if os.path.exists(user_cache):
# Add common application caches
try:
for app_dir in os.listdir(user_cache):
app_path = os.path.join(user_cache, app_dir)
if os.path.isdir(app_path):
locations.append(app_path)
except (OSError, PermissionError):
# Skip if we can't read cache directory
pass
# Thumbnail cache
thumb_cache = os.path.expanduser("~/.thumbnails")
if os.path.exists(thumb_cache):
locations.append(thumb_cache)
return [loc for loc in locations if loc and os.path.exists(loc)]
@staticmethod
def get_log_locations() -> List[str]:
"""Get Linux log file locations."""
locations = ["/var/log"]
# User logs
user_logs = os.path.expanduser("~/.local/share/logs")
if os.path.exists(user_logs):
locations.append(user_logs)
# Journal logs if systemd is used
if os.path.exists("/var/log/journal"):
locations.append("/var/log/journal")
return [loc for loc in locations if loc and os.path.exists(loc)]
@staticmethod
def get_system_maintenance_items() -> Dict[str, Dict[str, str]]:
"""Get Linux-specific system maintenance suggestions."""
return {
"apt_cache": {
"name": "APT Cache",
"path": "/var/cache/apt/archives",
"description": "APT包管理器下载的包文件",
"risk": "safe",
"size_hint": "几百MB",
"cleanup_command": "sudo apt-get clean",
},
"journal_logs": {
"name": "Systemd Journal",
"path": "/var/log/journal",
"description": "系统日志（可以限制大小）",
"risk": "confirm",
"size_hint": "几十MB到数GB",
"cleanup_command": "sudo journalctl --vacuum-size=500M",
},
"old_kernels": {
"name": "旧内核版本",
"path": "/boot",
"description": "已安装的旧Linux内核",
"risk": "confirm",
"size_hint": "每个内核200-500MB",
"note": "保留当前和上一个版本",
},
"snap_cache": {
"name": "Snap缓存",
"path": "/var/lib/snapd/snaps",
"description": "Snap包旧版本",
"risk": "safe",
"size_hint": "几百MB到数GB",
"cleanup_command": "sudo snap set system refresh.retain=2",
},
}
@staticmethod
def get_package_manager_cache() -> Dict[str, Dict[str, str]]:
"""Get package manager cache locations and cleanup commands."""
return {
"apt": {
"cache_dir": "/var/cache/apt/archives",
"clean_command": "sudo apt-get clean",
"autoremove_command": "sudo apt-get autoremove",
},
"yum": {
"cache_dir": "/var/cache/yum",
"clean_command": "sudo yum clean all",
},
"dnf": {
"cache_dir": "/var/cache/dnf",
"clean_command": "sudo dnf clean all",
},
"pacman": {
"cache_dir": "/var/cache/pacman/pkg",
"clean_command": "sudo pacman -Sc",
},
}
@staticmethod
def get_docker_locations() -> List[str]:
"""Get Docker cache locations on Linux."""
locations = [
"/var/lib/docker",
]
# Docker overlay2 storage
docker_overlay = "/var/lib/docker/overlay2"
if os.path.exists(docker_overlay):
locations.append(docker_overlay)
return [loc for loc in locations if os.path.exists(loc)]
@staticmethod
def check_disk_space(path: str = "/") -> Dict[str, float]:
"""Check disk space for Linux filesystems."""
try:
stat = os.statvfs(path)
total = stat.f_frsize * stat.f_blocks
free = stat.f_frsize * stat.f_bavail
used = total - free
return {
"total_gb": round(total / (1024**3), 2),
"used_gb": round(used / (1024**3), 2),
"free_gb": round(free / (1024**3), 2),
"usage_percent": round((used / total) * 100, 2) if total > 0 else 0,
}
except (OSError, AttributeError):
return {
"total_gb": 0,
"used_gb": 0,
"free_gb": 0,
"usage_percent": 0,
}
diskcleaner/platforms/macos.py
"""
macOS-specific platform functionality.
Provides macOS-specific temporary files, caches, and system cleanup locations.
"""
import os
from typing import Dict, List
class MacOSPlatform:
"""macOS platform-specific operations."""
@staticmethod
def get_temp_locations() -> List[str]:
"""Get macOS temporary file locations."""
locations = [
"/tmp",
"/private/tmp",
"/private/var/tmp",
]
# Per-user temp folders
var_folders = "/var/folders"
if os.path.exists(var_folders):
locations.append(var_folders)
return [loc for loc in locations if loc and os.path.exists(loc)]
@staticmethod
def get_cache_locations() -> List[str]:
"""Get macOS cache locations."""
locations = []
# User cache
user_cache = os.path.expanduser("~/Library/Caches")
if os.path.exists(user_cache):
locations.append(user_cache)
# Add common application caches
try:
for app_dir in os.listdir(user_cache):
app_path = os.path.join(user_cache, app_dir)
if os.path.isdir(app_path):
locations.append(app_path)
except (OSError, PermissionError):
# Skip if we can't read cache directory
pass
# System cache
system_cache = "/Library/Caches"
if os.path.exists(system_cache):
locations.append(system_cache)
return [loc for loc in locations if loc and os.path.exists(loc)]
@staticmethod
def get_log_locations() -> List[str]:
"""Get macOS log file locations."""
locations = []
# User logs
user_logs = os.path.expanduser("~/Library/Logs")
if os.path.exists(user_logs):
locations.append(user_logs)
# System logs
system_logs = "/Library/Logs"
if os.path.exists(system_logs):
locations.append(system_logs)
# Older macOS logs
old_logs = "/var/log"
if os.path.exists(old_logs):
locations.append(old_logs)
return [loc for loc in locations if loc and os.path.exists(loc)]
@staticmethod
def get_system_maintenance_items() -> Dict[str, Dict[str, str]]:
"""Get macOS-specific system maintenance suggestions."""
return {
"user_cache": {
"name": "用户缓存",
"path": os.path.expanduser("~/Library/Caches"),
"description": "应用程序缓存文件",
"risk": "safe",
"size_hint": "几百MB到数GB",
},
"ios_backups": {
"name": "iOS设备备份",
"path": os.path.expanduser("~/Library/Application Support/MobileSync/Backup"),
"description": "iPhone/iPad备份（删除前请确认）",
"risk": "confirm",
"size_hint": "每个备份数GB",
},
"xcode_derived_data": {
"name": "Xcode Derived Data",
"path": os.path.expanduser("~/Library/Developer/Xcode/DerivedData"),
"description": "Xcode编译中间文件",
"risk": "safe",
"size_hint": "几百MB到数GB",
},
"homebrew_cache": {
"name": "Homebrew缓存",
"path": "/Library/Caches/Homebrew",
"description": "Homebrew包管理器下载的文件",
"risk": "safe",
"size_hint": "几百MB",
"cleanup_command": "brew cleanup",
},
"trash": {
"name": "废纸篓",
"path": "~/.Trash",
"description": "已删除的文件（清空前请确认）",
"risk": "confirm",
"size_hint": "取决于删除的文件",
},
}
@staticmethod
def get_docker_locations() -> List[str]:
"""Get Docker cache locations on macOS."""
locations = []
# Docker Desktop on macOS
docker_mac = os.path.expanduser("~/Library/Containers/com.docker.docker")
if os.path.exists(docker_mac):
locations.append(docker_mac)
return [loc for loc in locations if loc and os.path.exists(loc)]
@staticmethod
def get_homebrew_locations() -> List[str]:
"""Get Homebrew cache locations."""
locations = [
"/Library/Caches/Homebrew",
"/usr/local/Cellar", # Intel Macs
"/opt/homebrew/Cellar", # Apple Silicon Macs
]
return [loc for loc in locations if loc and os.path.exists(loc)]
@staticmethod
def check_disk_space(path: str = "/") -> Dict[str, float]:
"""Check disk space for macOS filesystems."""
try:
stat = os.statvfs(path)
total = stat.f_frsize * stat.f_blocks
free = stat.f_frsize * stat.f_bavail
used = total - free
return {
"total_gb": round(total / (1024**3), 2),
"used_gb": round(used / (1024**3), 2),
"free_gb": round(free / (1024**3), 2),
"usage_percent": round((used / total) * 100, 2) if total > 0 else 0,
}
except (OSError, AttributeError):
return {
"total_gb": 0,
"used_gb": 0,
"free_gb": 0,
"usage_percent": 0,
}
diskcleaner/platforms/windows.py
"""
Windows-specific platform functionality.
Provides Windows-specific temporary files, caches, and system cleanup locations.
"""
import os
from pathlib import Path
from typing import Dict, List
class WindowsPlatform:
"""Windows platform-specific operations."""
@staticmethod
def _is_accessible(path: Path) -> bool:
"""
Check if a path is accessible and has content.
Args:
path: Path to check
Returns:
True if path exists, is accessible, and has content
"""
try:
if not path.exists():
return False
# Check if directory is accessible
if not path.is_dir():
return False
# Try to list contents to verify permissions
next(path.iterdir())
return True
except (PermissionError, OSError, StopIteration):
return False
@staticmethod
def _find_chrome_profiles(base_path: Path) -> List[Path]:
"""
Find all Chrome/Edge user profile directories.
Args:
base_path: Base path to User Data directory
Returns:
List of profile cache paths
"""
profiles = []
try:
if not base_path.exists():
return profiles
# Always check Default profile
default_cache = base_path / "Default" / "Cache"
if default_cache.exists():
profiles.append(default_cache)
# Check for other profiles (Profile 1, Profile 2, etc.)
user_data = base_path / "Default"
parent = user_data.parent
if parent.exists():
for item in parent.iterdir():
if item.is_dir() and item.name.startswith("Profile "):
cache_path = item / "Cache"
if cache_path.exists():
profiles.append(cache_path)
except (PermissionError, OSError):
pass
return profiles
@staticmethod
def get_temp_locations() -> List[str]:
"""
Get Windows temporary file locations with accessibility checks.
Returns:
List of accessible temp directory paths as strings
"""
locations = []
# User temp directories
temp_env = os.environ.get("TEMP", "")
if temp_env and WindowsPlatform._is_accessible(Path(temp_env)):
locations.append(temp_env)
tmp_env = os.environ.get("TMP", "")
if tmp_env and WindowsPlatform._is_accessible(Path(tmp_env)):
locations.append(tmp_env)
localappdata = Path(os.environ.get("LOCALAPPDATA", ""))
if localappdata.exists():
local_temp = localappdata / "Temp"
if WindowsPlatform._is_accessible(local_temp):
locations.append(str(local_temp))
# System temp directories
windir = Path(os.environ.get("WINDIR", "C:\\Windows"))
if windir.exists():
system_temp = windir / "Temp"
if WindowsPlatform._is_accessible(system_temp):
locations.append(str(system_temp))
prefetch = windir / "Prefetch"
if WindowsPlatform._is_accessible(prefetch):
locations.append(str(prefetch))
# Windows Update cache
software_dist = windir / "SoftwareDistribution" / "Download"
if WindowsPlatform._is_accessible(software_dist):
locations.append(str(software_dist))
return locations
@staticmethod
def get_cache_locations() -> List[str]:
"""
Get Windows cache locations with comprehensive browser and dev tool detection.
Returns:
List of accessible cache directory paths as strings
"""
localappdata = Path(os.environ.get("LOCALAPPDATA", ""))
appdata = Path(os.environ.get("APPDATA", ""))
programdata = Path(os.environ.get("PROGRAMDATA", ""))
userprofile = Path(os.environ.get("USERPROFILE", ""))
locations = []
# ========== Browser Caches ==========
if localappdata.exists():
# Internet Explorer/Edge Legacy cache
inet_cache = localappdata / "Microsoft" / "Windows" / "INetCache"
if WindowsPlatform._is_accessible(inet_cache):
locations.append(str(inet_cache))
# ========== Chrome Caches (11 actual cache locations) ==========
chrome_base = localappdata / "Google" / "Chrome" / "User Data"
if chrome_base.exists():
# Chrome main cache directories (use Path objects for proper path joining)
chrome_cache_dirs = [
Path("Default") / "Cache", # Main cache
Path("Default") / "Code Cache", # Code cache
Path("Default") / "GPUCache", # GPU cache
Path("Default") / "Service Worker" / "CacheStorage", # Service worker cache
Path("Default") / "Application Cache" / "Cache", # Application cache
Path("Default") / "IndexedDB", # IndexedDB database
Path("Default") / "Local Storage" / "leveldb", # Local storage
Path("Default") / "Session Storage", # Session storage
Path("Default") / "GraphQL", # GraphQL cache
Path("Default") / "Network" / "Persistent", # Persistent network cache
]
# Add Default profile caches
for cache_dir in chrome_cache_dirs:
cache_path = chrome_base / cache_dir
if WindowsPlatform._is_accessible(cache_path):
locations.append(str(cache_path))
# Add other Chrome profiles (Profile 1, Profile 2, etc.)
try:
default_dir = chrome_base / "Default"
if default_dir.parent.exists():
for profile_dir in default_dir.parent.iterdir():
if profile_dir.is_dir() and profile_dir.name.startswith("Profile "):
# Check main cache for this profile
profile_cache = profile_dir / "Cache"
if WindowsPlatform._is_accessible(profile_cache):
locations.append(str(profile_cache))
# Check code cache
code_cache = profile_dir / "Code Cache"
if WindowsPlatform._is_accessible(code_cache):
locations.append(str(code_cache))
except (PermissionError, OSError):
pass
# ========== Edge Caches (same structure as Chrome) ==========
edge_base = localappdata / "Microsoft" / "Edge" / "User Data"
if edge_base.exists():
# Edge main cache directories (use Path objects for proper path joining)
edge_cache_dirs = [
Path("Default") / "Cache",
Path("Default") / "Code Cache",
Path("Default") / "GPUCache",
Path("Default") / "Service Worker" / "CacheStorage",
Path("Default") / "Application Cache" / "Cache",
Path("Default") / "IndexedDB",
Path("Default") / "Local Storage" / "leveldb",
]
for cache_dir in edge_cache_dirs:
cache_path = edge_base / cache_dir
if WindowsPlatform._is_accessible(cache_path):
locations.append(str(cache_path))
# Add other Edge profiles
try:
default_dir = edge_base / "Default"
if default_dir.parent.exists():
for profile_dir in default_dir.parent.iterdir():
if profile_dir.is_dir() and profile_dir.name.startswith("Profile "):
profile_cache = profile_dir / "Cache"
if WindowsPlatform._is_accessible(profile_cache):
locations.append(str(profile_cache))
except (PermissionError, OSError):
pass
# ========== Firefox Cache ==========
if appdata.exists():
firefox_base = appdata / "Mozilla" / "Firefox" / "Profiles"
if firefox_base.exists():
try:
for profile_dir in firefox_base.iterdir():
if profile_dir.is_dir():
cache_dir = profile_dir / "cache2"
if WindowsPlatform._is_accessible(cache_dir):
locations.append(str(cache_dir))
except (PermissionError, OSError):
pass
# ========== JetBrains Caches (6.81 GB actual usage) ==========
if localappdata.exists():
# JetBrains IDE caches
jetbrains_cache = localappdata / "JetBrains"
if jetbrains_cache.exists():
try:
for ide_dir in jetbrains_cache.iterdir():
if ide_dir.is_dir():
# Each IDE has its own cache directory
locations.append(str(ide_dir))
except (PermissionError, OSError):
pass
# ========== Development Tool Caches ==========
if userprofile.exists():
# npm cache
npm_cache = userprofile / ".npm" # Legacy
npm_cache_new = userprofile / "AppData" / "Roaming" / "npm-cache" # New location
if WindowsPlatform._is_accessible(npm_cache):
locations.append(str(npm_cache))
if WindowsPlatform._is_accessible(npm_cache_new):
locations.append(str(npm_cache_new))
# yarn cache
yarn_cache = userprofile / ".yarn" / "cache"
if WindowsPlatform._is_accessible(yarn_cache):
locations.append(str(yarn_cache))
# yarn global cache
yarn_global = userprofile / "AppData" / "Local" / "Yarn" / "cache"
if WindowsPlatform._is_accessible(yarn_global):
locations.append(str(yarn_global))
# pnpm cache
pnpm_store = userprofile / ".pnpm-store"
if WindowsPlatform._is_accessible(pnpm_store):
locations.append(str(pnpm_store))
# pip cache
pip_cache = userprofile / ".cache" / "pip"
if WindowsPlatform._is_accessible(pip_cache):
locations.append(str(pip_cache))
# poetry cache
poetry_cache = userprofile / ".cache" / "pypoetry"
if WindowsPlatform._is_accessible(poetry_cache):
locations.append(str(poetry_cache))
# Gradle cache
gradle_cache = userprofile / ".gradle" / "caches"
if WindowsPlatform._is_accessible(gradle_cache):
locations.append(str(gradle_cache))
# Maven local repository
maven_repo = userprofile / ".m2" / "repository"
if WindowsPlatform._is_accessible(maven_repo):
locations.append(str(maven_repo))
# ========== Thumbnail Cache ==========
if localappdata.exists():
thumbnail_cache = localappdata / "Microsoft" / "Windows" / "Explorer"
if WindowsPlatform._is_accessible(thumbnail_cache):
locations.append(str(thumbnail_cache))
return locations
@staticmethod
def get_log_locations() -> List[str]:
"""
Get Windows log file locations with accessibility checks.
Returns:
List of accessible log directory paths as strings
"""
locations = []
localappdata = Path(os.environ.get("LOCALAPPDATA", ""))
if localappdata.exists():
history = localappdata / "Microsoft" / "Windows" / "History"
if WindowsPlatform._is_accessible(history):
locations.append(str(history))
webcache = localappdata / "Microsoft" / "Windows" / "WebCache"
if WindowsPlatform._is_accessible(webcache):
locations.append(str(webcache))
programdata = Path(os.environ.get("PROGRAMDATA", ""))
if programdata.exists():
wer = programdata / "Microsoft" / "Windows" / "WER"
if WindowsPlatform._is_accessible(wer):
locations.append(str(wer))
return locations
@staticmethod
def get_system_maintenance_items() -> Dict[str, Dict[str, str]]:
"""Get Windows-specific system maintenance suggestions."""
return {
"windows_update": {
"name": "Windows Update Cache",
"path": os.path.join(
os.environ.get("WINDIR", "C:\\Windows"), "SoftwareDistribution", "Download"
),
"description": "Windows Update下载的临时文件",
"risk": "safe",
"size_hint": "几百MB到数GB",
},
"recycle_bin": {
"name": "回收站",
"path": os.path.join(os.environ.get("SYSTEMDRIVE", "C:"), "$Recycle.Bin"),
"description": "已删除的文件（清空前请确认）",
"risk": "confirm",
"size_hint": "取决于删除的文件",
},
"prefetch": {
"name": "Prefetch缓存",
"path": os.path.join(os.environ.get("WINDIR", "C:\\Windows"), "Prefetch"),
"description": "应用程序预读数据（可安全删除）",
"risk": "safe",
"size_hint": "几十MB",
},
}
@staticmethod
def get_docker_locations() -> List[str]:
"""
Get Docker cache locations on Windows with accessibility checks.
Docker Desktop on Windows uses WSL2 backend.
Returns:
List of accessible Docker cache directory paths as strings
"""
locations = []
programdata = Path(os.environ.get("PROGRAMDATA", ""))
if programdata.exists():
docker_programdata = programdata / "Docker"
if WindowsPlatform._is_accessible(docker_programdata):
locations.append(str(docker_programdata))
appdata = Path(os.environ.get("APPDATA", ""))
if appdata.exists():
docker_appdata = appdata / "Docker"
if WindowsPlatform._is_accessible(docker_appdata):
locations.append(str(docker_appdata))
localappdata = Path(os.environ.get("LOCALAPPDATA", ""))
if localappdata.exists():
docker_local = localappdata / "Docker"
if WindowsPlatform._is_accessible(docker_local):
locations.append(str(docker_local))
return locations
@staticmethod
def check_disk_space(drive: str = None) -> Dict[str, float]:
"""Check disk space for Windows drives."""
import ctypes
if not drive:
drive = os.environ.get("SYSTEMDRIVE", "C:")
total_bytes = ctypes.c_ulonglong(0)
free_bytes = ctypes.c_ulonglong(0)
ctypes.windll.kernel32.GetDiskFreeSpaceExW(
ctypes.c_wchar_p(drive),
None,
ctypes.byref(total_bytes),
ctypes.byref(free_bytes),
)
total = total_bytes.value
free = free_bytes.value
used = total - free
return {
"total_gb": round(total / (1024**3), 2),
"used_gb": round(used / (1024**3), 2),
"free_gb": round(free / (1024**3), 2),
"usage_percent": round((used / total) * 100, 2) if total > 0 else 0,
}
docs/WIZARD_USAGE.md
# 交互式向导使用指南
## 概述
`interactive_wizard.py` 是一个完整的交互式磁盘清理向导，提供用户友好的分步界面。
## 功能特性
### 1. 欢迎页面
- 显示功能介绍
- 说明安全性承诺
- 用户确认后继续
### 2. 扫描模式选择
#### 快速扫描 (1秒)
- 扫描常见临时文件位置
- 文件数限制：10,000
- 时间限制：1秒
- 适合日常清理
#### 标准扫描 (2分钟)
- 全面扫描当前目录
- 包含子目录
- 文件数限制：100,000
- 时间限制：120秒
- 推荐模式
#### 深度扫描 (无限制)
- 扫描所有文件
- 使用配置默认值（1M文件，25秒）
- 适合彻底清理
#### 渐进式扫描
- 使用缓存增量扫描
- 后续扫描更快
- 适合定期清理
#### 自定义扫描
- 用户指定参数
- 最大文件数
- 最大扫描时间
### 3. 分类展示和安全级别
#### 安全级别 (OK)
- 临时文件
- 缓存文件
- 默认选中
#### 警告级别 (!)
- 开发工具索引
- 构建产物
- 需手动勾选
#### 危险级别 (X)
- 用户文档
- 重要文件
- 需逐个确认
### 4. 多级确认流程
#### 第一级：清理摘要
- 显示按风险分组的文件
- 总文件数和大小
- 风险级别说明
#### 第二级：危险操作确认
- 如果选择危险级别文件
- 需要输入 "I UNDERSTAND"
#### 第三级：最终确认
- 需要输入 "YES"
- 明确警告：永久删除
### 5. 执行清理
- 显示进度
- 创建备份
- 记录日志
- 显示结果
## 使用方法
### 基本用法
```bash
# 清理当前目录
python scripts/interactive_wizard.py
# 清理指定目录
python scripts/interactive_wizard.py /path/to/directory
# Windows
python scripts\interactive_wizard.py C:\Users\Username\Downloads
# Linux/macOS
python scripts/interactive_wizard.py ~/Downloads
```
### 示例会话
```
============================================================
磁盘清理向导
============================================================
欢迎使用磁盘清理工具！
功能特性:
- 智能分类：按类型、风险、时间三维分析
- 安全第一：多重确认，误删保护
- 重复文件：快速识别并清理重复内容
- 增量扫描：缓存机制，提升性能
安全承诺:
1. 不会删除任何文件，除非您明确确认
2. 所有操作都需要您输入 'YES' 确认
3. 危险操作需要额外输入 'I UNDERSTAND'
4. 所有删除操作都会记录日志
5. 可选备份功能，保护重要文件
============================================================
是否继续？ [Y/n]: Y
============================================================
选择扫描模式
============================================================
1. 快速扫描 (1秒)
2. 标准扫描 (2分钟)
3. 深度扫描 (无限制)
4. 渐进式扫描
5. 自定义扫描
0. 退出
请选择 (0-5): 2
正在扫描: D:\Projects
扫描模式: 标准扫描
扫描中 ✓ Completed (1,234 items in 0:02)
============================================================
扫描完成
============================================================
扫描文件数: 1,234
总大小: 256.78 MB
发现重复文件组: 5
============================================================
============================================================
清理报告查看选项
============================================================
1. 按类型查看
2. 按风险等级查看
3. 按时间查看
4. 查看重复文件
5. 详细列表
6. 查看统计摘要
0. 返回
============================================================
请选择 (0-6): 2
============================================================
按风险等级分类
============================================================
1. 安全删除: 45 文件, 123.45 MB (0/45 已选)
2. 需要确认: 12 文件, 45.67 MB (0/12 已选)
3. 受保护: 3 文件, 10.00 MB (0/3 已选)
操作:
输入编号查看类别详情
a. 全选安全文件
c. 清除选择
s. 显示已选文件
0. 返回
请选择: a
已选择 45 个文件
[... 继续选择文件 ...]
============================================================
清理确认
============================================================
即将删除的文件按风险分组:
[OK] 安全级别: 45 文件, 123.45 MB
临时文件、缓存等，可安全删除
[!] 警告级别: 12 文件, 45.67 MB
开发工具索引、构建产物等，请确认
------------------------------------------------------------
总计: 57 文件, 169.12 MB
============================================================
此操作将永久删除选定的文件！
确认删除？输入 'YES' 继续: YES
开始清理...
✓ 清理完成！
删除文件: 57
释放空间: 169.12 MB
```
## 集成组件
向导集成了以下现有组件：
- `InteractiveCleanupUI` - 交互式展示和选择
- `ProgressBar` - 进度条显示
- `IndeterminateProgress` - 不定长进度显示
- `DirectoryScanner` - 目录扫描
- `SmartCleanupEngine` - 智能清理引擎
- `FileClassifier` - 文件分类器
- `DuplicateFinder` - 重复文件检测
- `SafetyChecker` - 安全检查
## 测试
运行测试套件：
```bash
python scripts/test_wizard.py
```
测试包括：
- 向导初始化
- 扫描模式配置
- 大小格式化
- 风险级别指示器
- 扫描参数设置
## 安全特性
1. **多重确认**
- 每个删除操作都需要明确确认
- 危险操作需要额外确认步骤
2. **备份机制**
- 可选备份功能
- 删除前创建备份
3. **日志记录**
- 所有删除操作记录到日志
- 日志位置：`~/.disk-cleaner/logs/cleanup.log`
4. **权限检查**
- 验证文件访问权限
- 跳过无法访问的文件
5. **文件锁检测**
- 检测正在使用的文件
- 避免删除锁定文件
## ASCII 安全输出
脚本输出使用 ASCII 字符，确保在所有终端环境下正常显示：
- 使用 `[OK]`、`[!]`、`[X]` 代替 emoji
- 风险级别使用文本标识符
- 进度条使用 ASCII 字符
Agent 汇报时可以使用 emoji 提供更好的视觉体验。
## 配置
向导使用 `~/.disk-cleaner/config.yaml` 配置文件：
```yaml
# 受保护的路径和文件
protected:
paths:
- "important-project/"
- "database/"
patterns:
- "*.database"
- "*.db"
# 清理规则
rules:
- name: "旧日志"
pattern: "*.log"
category: "日志"
risk: "safe"
age_threshold: 60
# 安全设置
safety:
check_file_locks: true
verify_permissions: true
backup_before_delete: true
# 扫描设置
scan:
use_incremental: true
cache_ttl: 7 # 天
```
## 故障排除
### 问题：扫描速度慢
**解决方案：**
- 使用 "快速扫描" 模式
- 使用 "渐进式扫描" 启用缓存
- 减少扫描范围
### 问题：权限错误
**解决方案：**
- 使用管理员/root权限运行
- 检查配置文件中的受保护路径
- 跳过系统目录
### 问题：编码错误
**解决方案：**
- 确保终端支持 UTF-8
- Windows: `chcp 65001`
- Linux: `export LANG=en_US.UTF-8`
## 最佳实践
1. **首次使用**
- 从 "快速扫描" 开始
- 只选择 "安全级别" 文件
- 查看日志确认结果
2. **定期清理**
- 使用 "渐进式扫描"
- 启用缓存提升性能
- 设置定时任务自动运行
3. **彻底清理**
- 使用 "深度扫描"
- 仔细检查 "危险级别" 文件
- 创建备份以防万一
4. **开发环境**
- 使用 "自定义扫描"
- 排除 `node_modules` 等大型目录
- 定期清理构建产物
## 相关文档
- `README.md` - 项目概述
- `SKILL.md` - Skill 定义
- `analyze_disk.py` - 磁盘分析工具
- `clean_disk.py` - 清理工具
## 贡献
欢迎贡献！请参阅 `CONTRIBUTING.md` 了解详情。
## 许可证
MIT License
INSTALL.md
# Disk Cleaner 技能包 - 安装和使用指南
## 📦 技能包信息
- **名称**: disk-cleaner
- **版本**: 2.0.0
- **类型**: Claude Code 技能包
- **平台**: Windows / macOS / Linux (跨平台)
- **Python 要求**: 3.7+
## 🎯 主要功能
1. **高性能磁盘扫描** - 使用 os.scandir() 优化，速度提升 3-5 倍
2. **智能清理** - 安全清理临时文件、缓存、日志等
3. **磁盘监控** - 实时监控磁盘使用情况，设置警告阈值
4. **跨平台支持** - 完全支持 Windows、macOS、Linux
5. **独立运行** - 无需预先安装任何依赖
## 📥 安装方法
### 方法 1: 直接解压（推荐）
1. 下载 `disk-cleaner.skill` 文件
2. 重命名为 `disk-cleaner.zip`
3. 解压到你的技能目录：
- **Windows**: `%USERPROFILE%\.claude\skills\disk-cleaner\`
- **macOS/Linux**: `~/.claude/skills/disk-cleaner/`
### 方法 2: Claude Code 安装
在 Claude Code 中使用：
```
/install-skill path/to/disk-cleaner.skill
```
### 方法 3: 手动安装
```bash
# 创建技能目录
mkdir -p ~/.claude/skills/disk-cleaner
# 复制文件
cp -r disk-cleaner/* ~/.claude/skills/disk-cleaner/
```
## ✅ 验证安装
运行诊断工具检查安装：
```bash
cd ~/.claude/skills/disk-cleaner
python scripts/check_skill.py
```
预期输出：
```
============================================================
诊断总结
============================================================
通过: 6/6
[OK] Python 版本
[OK] 操作系统
[OK] 文件结构
[OK] 模块导入
[OK] 文件权限
[OK] 脚本测试
🎉 所有检查通过！技能包可以正常使用。
```
## 🚀 使用方法
### 1. 分析磁盘空间
```bash
# 分析当前驱动器
python scripts/analyze_disk.py
# 分析特定路径
python scripts/analyze_disk.py --path "D:\Projects"
# 显示前 50 个最大项目
python scripts/analyze_disk.py --top 50
# 输出 JSON 格式
python scripts/analyze_disk.py --json --output report.json
# 分析大目录（自定义限制）
python scripts/analyze_disk.py --path "D:/" --file-limit 2000000 --time-limit 600
```
### 2. 清理垃圾文件
**⚠️ 重要**: 首次使用请务必使用 `--dry-run` 预览！
```bash
# 预览清理（安全模式）
python scripts/clean_disk.py --dry-run
# 实际清理
python scripts/clean_disk.py --force
# 清理特定类别
python scripts/clean_disk.py --temp --cache --dry-run
python scripts/clean_disk.py --logs --dry-run
python scripts/clean_disk.py --recycle --dry-run
# 清理旧下载文件（90 天以上）
python scripts/clean_disk.py --downloads 90 --dry-run
# 清理自定义路径
python scripts/clean_disk.py --path "D:\Temp" --dry-run
```
### 3. 监控磁盘使用
```bash
# 检查当前状态
python scripts/monitor_disk.py
# 持续监控（每 60 秒）
python scripts/monitor_disk.py --watch
# 自定义阈值
python scripts/monitor_disk.py --warning 70 --critical 85
# 自定义监控间隔（5 分钟）
python scripts/monitor_disk.py --watch --interval 300
# 仅显示警报（CI/CD 友好）
python scripts/monitor_disk.py --alerts-only
```
## 🧪 高级功能
### 智能扫描优化
技能包内置高性能扫描算法：
- **os.scandir() 优化**: 3-5 倍速度提升
- **并发扫描**: 多线程 I/O 操作
- **智能采样**: 大目录快速估算
- **内存自适应**: 自动监控内存使用
- **早期停止**: 文件数/时间限制
```bash
# 使用智能采样快速分析
python scripts/analyze_disk.py --sample
# 设置文件数限制
python scripts/analyze_disk.py --file-limit 1000000
# 设置时间限制
python scripts/analyze_disk.py --time-limit 300
```
### 错误诊断
如果遇到问题：
```bash
# 运行完整诊断
python scripts/check_skill.py
# 测试模块导入
python scripts/skill_bootstrap.py --test-import
# 启用调试模式
DISK_CLEANER_DEBUG=true python scripts/analyze_disk.py
```
## 🛡️ 安全特性
### 保护路径
技能包永远不会删除以下路径：
- **Windows**: `C:\Windows`, `C:\Program Files`, `C:\ProgramData`
- **macOS**: `/System`, `/Library`, `/Applications`
- **Linux**: `/usr`, `/bin`, `/sbin`, `/lib`, `/etc`
### 保护扩展
以下文件扩展名永远不会被删除：
```
.exe, .dll, .sys, .drv, .bat, .cmd, .ps1, .vbs
.sh, .bash, .zsh, .fish
.app, .dmg, .pkg
.deb, .rpm, .msi, .iso
.vhd, .vhdx, .vmdk
```
### 安全模式
默认情况下，所有清理操作都是 `--dry-run`（预览）模式，必须使用 `--force` 才会实际删除文件。
## 📊 性能指标
根据测试数据：
| 操作 | 性能 |
|------|------|
| 扫描 100K 文件 | ~2-3 秒 |
| 扫描 500K 文件 | ~10-15 秒 |
| 清理 10K 文件 | ~5-10 秒 |
| 内存使用 | <50MB |
## 🐛 故障排除
### 问题：模块导入失败
**症状**:
```
ImportError: No module named 'diskcleaner'
```
**解决方案**:
1. 确保从技能目录运行脚本
2. 运行诊断：`python scripts/check_skill.py`
3. 检查文件结构是否完整
### 问题：编码错误（Windows）
**症状**:
```
UnicodeEncodeError: 'gbk' codec can't encode character
```
**解决方案**:
技能包已内置编码处理，如果仍有问题：
```bash
chcp 65001 # 设置控制台为 UTF-8
python scripts/analyze_disk.py
```
### 问题：权限错误
**症状**:
```
PermissionError: [Errno 13] Permission denied
```
**解决方案**:
- 技能包会自动跳过无权限的文件/目录
- 以管理员身份运行（如果需要）
- 检查文件/目录权限设置
## 📝 技能包结构
```
disk-cleaner/
├── SKILL.md # 技能说明文档
├── README.txt # 快速开始指南
├── skill.json # 技能包元数据
├── scripts/ # 可执行脚本
│ ├── analyze_disk.py # 磁盘分析工具
│ ├── clean_disk.py # 清理工具
│ ├── monitor_disk.py # 监控工具
│ ├── check_skill.py # 诊断工具
│ ├── skill_bootstrap.py # 引导模块
│ ├── package_skill.py # 打包工具
│ └── scheduler.py # 调度器
├── diskcleaner/ # 核心模块
│ ├── __init__.py
│ ├── config/ # 配置管理
│ ├── core/ # 核心功能
│ ├── optimization/ # 性能优化
│ └── platforms/ # 平台适配
└── references/ # 参考文档
└── temp_locations.md # 临时文件位置
```
## 🔄 更新技能包
当有新版本时：
1. 备份当前版本：
```bash
mv ~/.claude/skills/disk-cleaner ~/.claude/skills/disk-cleaner.backup
```
2. 安装新版本（参考安装方法）
3. 验证：
```bash
python scripts/check_skill.py
```
4. 如果满意，删除备份：
```bash
rm -rf ~/.claude/skills/disk-cleaner.backup
```
## 📞 获取帮助
- 运行 `--help` 查看详细选项
- 运行诊断工具获取详细信息
- 查看 SKILL.md 了解更多细节
- 查看 references/temp_locations.md 了解平台特定信息
## ⚖️ 许可证
MIT License - 详见项目文件
---
**享受干净的磁盘！** 🎉
NO_PYTHON_GUIDE.md
# 🚨 我没有 Python，怎么用这个技能？
## 不要担心！你有几个选择
---
## 选项 1: 安装 Python（推荐，5 分钟）
### 为什么推荐？
- ✅ 一次安装，永久使用
- ✅ 可以运行所有 Python 脚本
- ✅ 这个技能包会完全发挥作用
- ✅ Python 是很多开发工具的基础
### Windows 用户（最简单）
1. **下载 Python**
- 访问：https://www.python.org/downloads/
- 点击黄色的大按钮 "Download Python 3.x.x"
2. **安装 Python**
- 运行下载的安装程序
- ⚠️ **非常重要**: 勾选底部的 "Add Python to PATH"
- 点击 "Install Now"
3. **验证安装**
```bash
# 打开新的命令提示符（CMD）
python --version
```
如果看到 `Python 3.x.x`，说明安装成功！
4. **使用技能包**
```bash
cd skills\disk-cleaner
python scripts\check_skill.py
```
### macOS 用户
1. **使用 Homebrew（如果已安装）**
```bash
brew install python@3.11
```
2. **或者从官网下载**
- 访问：https://www.python.org/downloads/macos/
- 下载并安装
3. **验证安装**
```bash
python3 --version
```
4. **使用技能包**
```bash
cd skills/disk-cleaner
python3 scripts/check_skill.py
```
### Linux 用户
```bash
# Ubuntu/Debian
sudo apt update
sudo apt install python3
# Fedora/RHEL
sudo dnf install python3
# 验证
python3 --version
```
---
## 选项 2: 使用在线 Python（无需安装）
### Google Colab（推荐）
1. 访问：https://colab.research.google.com/
2. 点击 "新建笔记本"
3. 上传技能包文件
4. 在单元格中运行：
```python
!python scripts/check_skill.py
```
### Replit
1. 访问：https://replit.com/
2. 创建新的 Python Repl
3. 上传技能包文件
4. 在终端中运行脚本
---
## 选项 3: 让 Agent 帮你
### 如果你使用 Claude Code
直接告诉 Claude：
```
"我想分析我的磁盘空间，但我不确定是否安装了 Python"
"请帮我检查 Python 环境"
"请帮我安装 Python"
```
### Agent 会做什么？
1. **自动检查** Python 是否已安装
2. **如果没有**，引导你安装
3. **验证安装**是否成功
4. **帮你运行**技能包
### 示例对话
```
你: 我的 C 盘快满了，帮我分析一下
Claude: 我来帮你检查 Python 环境...
[检查中...]
✅ 发现 Python 3.9.0
✅ 找到技能包: C:\...\skills\disk-cleaner
🔍 开始分析磁盘空间...
[运行分析...]
分析完成！发现以下大文件夹：
...
```
```
你: 我有 Python 吗？
Claude: 让我检查一下...
❌ 未找到 Python
🪟 你使用的是 Windows，请按以下步骤安装：
1. 访问 https://www.python.org/downloads/
2. 下载 Python 3.11
3. 安装时勾选 "Add Python to PATH"
4. 完成后重启命令行
需要我提供更详细的指导吗？
```
---
## 选项 4: 使用系统自带工具（临时方案）
如果你暂时不想安装 Python，可以使用系统自带的工具：
### Windows
1. **磁盘清理**
- 打开"此电脑"
- 右键点击 C 盘，选择"属性"
- 点击"磁盘清理"
2. **存储感知**
- 设置 > 系统 > 存储
- 开启"存储感知"
### macOS
1. **关于本机 > 存储空间**
- 点击"管理"
- 查看建议并清理
2. **使用终端命令**
```bash
# 查看文件夹大小
du -sh ~/Documents
du -sh ~/Downloads
```
### Linux
```bash
# 查看磁盘使用
df -h
# 查看文件夹大小
du -sh ~/*
```
**注意**: 系统工具功能有限，不如这个技能包强大。
---
## 📊 选项对比
| 选项 | 优点 | 缺点 | 推荐度 |
|------|------|------|--------|
| 安装 Python | 功能完整，一次安装永久使用 | 需要 5 分钟安装 | ⭐⭐⭐⭐⭐ |
| 在线 Python | 无需安装 | 需要上传文件，速度较慢 | ⭐⭐⭐ |
| Agent 协助 | 最简单，有指导 | 需要交互 | ⭐⭐⭐⭐ |
| 系统工具 | 无需任何安装 | 功能有限 | ⭐⭐ |
---
## 🎯 推荐流程
1. **先问 Agent**: "帮我检查 Python 环境"
2. **如果已有**: 直接使用技能包
3. **如果没有**: Agent 会引导你安装
4. **安装后**: 享受完整的磁盘管理功能
---
## ❓ 常见问题
### Q: 安装 Python 会影响我的系统吗？
**A**: 不会。Python 是一个解释器，只是让你能运行 Python 脚本。不会修改系统设置。
### Q: 我可以卸载 Python 吗？
**A**: 可以。安装程序会提供卸载选项，或者在控制面板中卸载。
### Q: Python 安全吗？
**A**: 是的。Python 是世界上最流行的编程语言之一，被数百万人使用。
### Q: 安装需要多少空间？
**A**: Python 大约需要 200-300MB 空间。
### Q: 我有多个 Python 版本怎么办？
**A**: 没关系。技能包会自动找到可用的 Python 3.7+ 版本。
---
## 💡 最后建议
**如果你**:
- 🔧 经常需要管理磁盘 → **安装 Python**（一劳永逸）
- 📊 只是想看看磁盘情况 → **让 Agent 帮你**（最简单）
- 🚫 不想安装任何东西 → **使用系统工具**（临时方案）
- 🌐 只需偶尔使用 → **在线 Python**（无需安装）
---
## 📞 仍需要帮助？
告诉 Agent：
```
"我没有 Python，请详细指导我安装"
"我想使用 disk-cleaner 但不知道怎么开始"
"请帮我检查我的系统配置"
```
Agent 会根据你的情况提供个性化的指导！
README.md
# Disk Cleaner Skill
A high-performance cross-platform disk space monitoring, analysis, and cleaning toolkit for Claude Code.
## Quick Start
### As Claude Code Skill
Install directly from GitHub:
```bash
npx add-skill gccszs/disk-cleaner
```
### Manual Installation
1. Download `disk-cleaner.skill` from the [Releases](https://github.com/gccszs/disk-cleaner/releases) page
2. Install via Claude Code: `/skill install path/to/disk-cleaner.skill`
## Features
- **Disk Space Analysis**: Identify large files and directories consuming space
- **Smart Cleanup**: Safe removal of temporary files, caches, logs
- **Duplicate Detection**: Find and remove duplicate files
- **Disk Monitoring**: Real-time monitoring with alert thresholds
- **Cross-Platform**: Windows, Linux, macOS support
- **3-5x Faster**: Optimized scanning with os.scandir()
## Usage
### Analyze Disk Space
```bash
python scripts/analyze_disk.py --top 50
```
### Clean Junk Files (Preview)
```bash
python scripts/clean_disk.py --dry-run
```
### Monitor Disk Usage
```bash
python scripts/monitor_disk.py --watch
```
## Skill Structure
```
disk-cleaner/
├── SKILL.md # Skill definition
├── README.md # This file
├── diskcleaner/ # Core Python module
├── scripts/ # Executable scripts
└── references/ # Reference documentation
```
## Documentation
- [Full Skill Documentation](SKILL.md)
- [Project Repository](https://github.com/gccszs/disk-cleaner)
## License
MIT License
references/temp_locations.md
# Platform-Specific Temporary File Locations
This document provides comprehensive information about temporary file locations across different operating systems.
## Windows
### Environment Variables
- `%TEMP%` - User temporary files
- `%TMP%` - User temporary files (alias)
- `%LOCALAPPDATA%\Temp` - Local application temp
### System Locations
- `C:\Windows\Temp` - System temporary files
- `C:\Windows\Prefetch` - Application prefetch data
- `C:\Windows\SoftwareDistribution\Download` - Windows Update cache
- `C:\Windows\Logs` - Windows logs
- `C:\Windows\Debug` - Debug logs
- `C:\Windows\Minidump` - Crash dumps
### User Profile Locations
- `%LOCALAPPDATA%\Microsoft\Windows\INetCache` - Internet Explorer cache
- `%LOCALAPPDATA%\Microsoft\Windows\History` - Browser history
- `%LOCALAPPDATA%\Microsoft\Windows\WebCache` - Web cache
- `%LOCALAPPDATA%\Temp` - Local temp files
- `%APPDATA%\Microsoft\Windows\Recent` - Recent files shortcuts
- `%USERPROFILE%\AppData\LocalLow\Microsoft\CryptnetUrlCache\Content` - Crypto cache
- `%USERPROFILE%\AppData\LocalLow\Microsoft\CryptnetUrlCache\MetaData` - Crypto metadata
### Browser Caches
- Chrome: `%LOCALAPPDATA%\Google\Chrome\User Data\Default\Cache`
- Chrome: `%LOCALAPPDATA%\Google\Chrome\User Data\Default\Code Cache`
- Edge: `%LOCALAPPDATA%\Microsoft\Edge\User Data\Default\Cache`
- Firefox: `%APPDATA%\Mozilla\Firefox\Profiles\*.default-release\cache2`
- Firefox: `%LOCALAPPDATA%\Mozilla\Firefox\Profiles\*.default-release\startupCache`
### Application Caches
- VS Code: `%USERPROFILE%\.vscode\logs`
- npm: `%LOCALAPPDATA%\npm-cache`
- pip: `%LOCALAPPDATA%\pip\cache`
- yarn: `%LOCALAPPDATA%\Yarn\Cache`
- Gradle: `%USERPROFILE%\.gradle\caches`
- Maven: `%USERPROFILE%\.m2\repository`
### Recycle Bin
- `C:\$Recycle.Bin\` - All users' recycle bins
## macOS
### System Locations
- `/tmp` - System temporary files
- `/private/tmp` - Private temporary files
- `/private/var/tmp` - Variable temporary files
- `/private/var/folders` - Per-session temporary files
- `/Library/Caches` - System-wide caches
- `/Library/Logs` - System logs
### User Locations
- `~/Library/Caches` - User application caches
- `~/Library/Logs` - User application logs
- `~/Library/Application Support/CrashReporter` - Crash reports
- `~/.Trash` - User's trash
- `~/Downloads` - Downloaded files
### Browser Caches
- Safari: `~/Library/Caches/com.apple.Safari`
- Chrome: `~/Library/Caches/Google/Chrome/Default/Cache`
- Firefox: `~/Library/Caches/Firefox/Profiles/*.default-release`
### Development Tools
- npm: `~/.npm`
- pip: `~/Library/Caches/pip`
- Homebrew: `/Library/Caches/Homebrew`
- Docker: `~/Library/Containers/com.docker.docker/Data`
### iOS Backups
- `~/Library/Application Support/MobileSync/Backup`
## Linux
### System Locations
- `/tmp` - Temporary files (cleared on reboot)
- `/var/tmp` - Persistent temporary files
- `/var/cache` - Application cache
- `/var/log` - System logs
- `/var/crash` - Crash dumps
### Package Manager Caches
- apt (Debian/Ubuntu): `/var/cache/apt/archives`
- dnf/yum (Fedora/RHEL): `/var/cache/dnf`
- pacman (Arch): `/var/cache/pacman/pkg`
- snap: `/var/lib/snapd/snaps`
### User Locations
- `~/.cache` - User cache (XDG standard)
- `~/.local/share/Trash` - User's trash
- `~/.thumbnails` - Thumbnail cache
- `~/.local/share/Trash/files` - Trash files
- `~/.local/share/Trash/info` - Trash metadata
### Browser Caches
- Chrome: `~/.cache/google-chrome`
- Firefox: `~/.cache/mozilla/firefox`
- Chromium: `~/.cache/chromium`
### Development Tools
- npm: `~/.npm`
- yarn: `~/.yarn/cache`
- pip: `~/.cache/pip`
- conda: `~/.conda/pkgs`
- Docker: `/var/lib/docker`
## Safety Guidelines
### Never Delete
- System directories (`/System`, `/Windows`, `/Program Files`, `/usr`, `/bin`, `/sbin`, `/lib`)
- User executables (`.exe`, `.dll`, `.sys`, `.app`, `.deb`, `.rpm`)
- Critical system files (boot loaders, kernel files)
- Active database files
- Virtual machine disk images (unless verified unused)
### Always Verify Before Deleting
- Large files in user directories
- Application data directories
- Custom configuration files
- Files with unknown purposes
### Safe to Delete (Generally)
- `*.tmp` files
- `*.log` files (older than 30 days)
- `*.cache` directories
- `*.bak` files
- `~$*` temporary office files
- `.DS_Store` (macOS)
- `Thumbs.db` (Windows)
- Browser cache
- Old download files (with user verification)
scripts/analyze_disk.py
#!/usr/bin/env python3
"""
Disk Space Analyzer - Cross-platform disk space analysis tool
Analyzes disk usage and identifies large files and directories
Enhanced with progress bars and performance optimizations.
"""
import json
import os
import platform
import sys
from datetime import datetime
from pathlib import Path
from typing import Dict, List, Optional
# Use smart bootstrap module to import diskcleaner
try:
# Add parent directory of current script to path for importing skill_bootstrap
script_dir = Path(__file__).parent.resolve()
if str(script_dir) not in sys.path:
sys.path.insert(0, str(script_dir))
from skill_bootstrap import import_diskcleaner_modules, setup_skill_environment
# Setup skill environment and import modules
IMPORT_SUCCESS, MODULES = import_diskcleaner_modules()
PROGRESS_AVAILABLE = IMPORT_SUCCESS
if IMPORT_SUCCESS:
ProgressBar = MODULES["ProgressBar"]
DirectoryScanner = MODULES["DirectoryScanner"]
DuplicateFinder = MODULES["DuplicateFinder"]
else:
ProgressBar = None
DirectoryScanner = None
DuplicateFinder = None
except Exception as e:
# If bootstrap module also fails, try direct import (may be installed)
try:
from diskcleaner.core.progress import ProgressBar
from diskcleaner.core.scanner import DirectoryScanner
PROGRESS_AVAILABLE = True
print(f"[Warning] Skill bootstrap failed, using installed version: {e}", file=sys.stderr)
except ImportError:
PROGRESS_AVAILABLE = False
ProgressBar = None
DirectoryScanner = None
print(f"[Warning] Cannot import diskcleaner module, some features unavailable: {e}", file=sys.stderr)
class DiskAnalyzer:
def __init__(
self,
path: str = None,
top_n: int = 20,
show_progress: bool = True,
max_files: int = None,
max_seconds: int = None,
include_windows: bool = False,
):
self.path = path or self._get_default_path()
self.top_n = top_n
self.platform = platform.system()
self.system = platform.system().lower()
self.show_progress = show_progress and PROGRESS_AVAILABLE and sys.stdout.isatty()
# More reasonable defaults for large disks
self.max_files = max_files if max_files is not None else 500000
self.max_seconds = max_seconds if max_seconds is not None else 120
self.include_windows = include_windows
def _get_default_path(self) -> str:
"""Get default path based on platform"""
system = platform.system()
if system == "Windows":
return "C:\\"
elif system == "Darwin": # macOS
return "/"
else: # Linux
return "/"
def quick_sample(self, sample_time: float = 1.0) -> Dict:
"""
Quick sampling analysis - estimate directory characteristics within 1 second
Args:
sample_time: Sampling time (seconds)
Returns:
Dictionary containing estimation information
"""
import time
print(f"\n[*] Quick sampling analysis... ({sample_time}s)")
file_count = 0
total_size = 0
sample_dirs = 0
start = time.time()
scan_path = Path(self.path)
try:
# Use os.scandir for quick sampling
for root, dirs, files in os.walk(str(scan_path)):
if time.time() - start > sample_time:
break
sample_dirs += len(dirs)
file_count += len(files)
# Sample file sizes (max 100)
for i, f in enumerate(files[:100]):
try:
file_path = Path(root) / f
if file_path.is_file():
total_size += file_path.stat().st_size
except (OSError, PermissionError):
pass
except Exception as e:
print(f"Sampling error: {e}")
elapsed = time.time() - start
# Calculate estimates
if elapsed > 0:
files_per_second = file_count / elapsed
else:
files_per_second = 0
# Estimate total time (2x safety margin)
if files_per_second > 0:
estimated_seconds = (file_count / files_per_second) * 2
else:
estimated_seconds = 0
result = {
"sample_file_count": file_count,
"sample_size_gb": round(total_size / (1024**3), 2),
"sample_dirs": sample_dirs,
"files_per_second": round(files_per_second, 0),
"estimated_time_seconds": round(estimated_seconds, 1),
}
# Display sampling results
print("\n[i] Sampling results:")
print(f" Files found: {file_count:,}")
print(f" Directories: {sample_dirs:,}")
print(f" Scan speed: {result['files_per_second']:,} files/sec")
if estimated_seconds > 0:
if estimated_seconds < 60:
print(f" Estimated full scan: {estimated_seconds:.0f} seconds")
else:
print(f" Estimated full scan: {estimated_seconds/60:.1f} minutes")
if estimated_seconds > 120: # Over 2 minutes
print("\n[i] Recommendations:")
print(" Use --file-limit to limit file count")
print(" Use --time-limit to limit time")
print(" Or use --sample to view sampling results only")
return result
def get_disk_usage(self) -> Dict:
"""Get overall disk usage statistics"""
usage = os.statvfs(self.path) if hasattr(os, "statvfs") else None
if usage:
total = usage.f_frsize * usage.f_blocks
used = usage.f_frsize * (usage.f_blocks - usage.f_bavail)
free = usage.f_frsize * usage.f_bavail
else:
# Windows fallback
import ctypes
total_bytes = ctypes.c_ulonglong(0)
free_bytes = ctypes.c_ulonglong(0)
ctypes.windll.kernel32.GetDiskFreeSpaceExW(
ctypes.c_wchar_p(self.path),
None,
ctypes.byref(total_bytes),
ctypes.byref(free_bytes),
)
total = total_bytes.value
free = free_bytes.value
used = total - free
return {
"path": self.path,
"total_gb": round(total / (1024**3), 2),
"used_gb": round(used / (1024**3), 2),
"free_gb": round(free / (1024**3), 2),
"usage_percent": round((used / total) * 100, 2) if total > 0 else 0,
}
def scan_directory(self, path: str = None, max_depth: int = 3) -> List[Dict]:
"""
Scan directory and find largest subdirectories and files.
Uses optimized DirectoryScanner with progress bar if available.
"""
scan_path = Path(path or self.path)
results = {"directories": [], "files": []}
try:
# Use optimized scanner if available
if PROGRESS_AVAILABLE:
try:
# Use DirectoryScanner with progress tracking
# Use instance limits if provided, otherwise use sensible defaults
max_files = self.max_files if self.max_files is not None else 1000000
max_seconds = self.max_seconds if self.max_seconds is not None else 300
scanner = DirectoryScanner(
str(scan_path),
max_files=max_files,
max_seconds=max_seconds,
cache_enabled=False, # Disable cache for one-time scan
include_windows=getattr(self, 'include_windows', False),
)
print(f"\n[*] Scanning {scan_path}...")
# Collect all entries with progress
all_dirs = {}
all_files = []
for file_info in scanner.scan_generator():
if file_info.is_dir:
# Store directory info for later size calculation
all_dirs[file_info.path] = file_info
elif not file_info.is_dir and file_info.size > 10 * 1024 * 1024:
# Only track files > 10MB
all_files.append(
{
"path": file_info.path,
"name": file_info.name,
"size_gb": round(file_info.size / (1024**3), 2),
"size_mb": round(file_info.size / (1024**2), 2),
}
)
# Now calculate directory sizes (top-level only)
print("[i] Analyzing directory sizes...")
for dir_path, dir_info in all_dirs.items():
if Path(dir_path).parent == scan_path:
# Only immediate subdirectories
try:
size = self._get_dir_size_fast(Path(dir_path))
if size > 0:
results["directories"].append(
{
"path": dir_path,
"name": dir_info.name,
"size_gb": round(size / (1024**3), 2),
"size_mb": round(size / (1024**2), 2),
}
)
except (PermissionError, OSError):
pass
results["files"] = all_files
if scanner.stopped_early:
print(f"[!] Scan stopped early: {scanner.stop_reason}")
except (PermissionError, OSError) as e:
# Fallback to old method if scanner fails
print(f"Scanner failed, using fallback method: {e}", file=sys.stderr)
return self._scan_directory_fallback(scan_path, max_depth)
else:
# Fallback to old method
return self._scan_directory_fallback(scan_path, max_depth)
except (PermissionError, OSError) as e:
print(f"Error scanning {scan_path}: {e}", file=sys.stderr)
# Sort by size
results["directories"].sort(key=lambda x: x["size_gb"], reverse=True)
results["files"].sort(key=lambda x: x["size_gb"], reverse=True)
# Keep only top N
results["directories"] = results["directories"][: self.top_n]
results["files"] = results["files"][: self.top_n]
return results
def _scan_directory_fallback(self, scan_path: Path, max_depth: int = 3) -> Dict:
"""Fallback scanning method using Path.iterdir()"""
results = {"directories": [], "files": []}
try:
# Count total items for progress bar
if self.show_progress:
items = list(scan_path.iterdir())
progress = ProgressBar(len(items), prefix="Scanning")
else:
items = scan_path.iterdir()
progress = None
# Scan directories
for item in items:
if item.is_dir() and not item.is_symlink():
try:
size = self._get_dir_size(item, max_depth=1)
if size > 0:
results["directories"].append(
{
"path": str(item),
"name": item.name,
"size_gb": round(size / (1024**3), 2),
"size_mb": round(size / (1024**2), 2),
}
)
except (PermissionError, OSError):
pass
elif item.is_file():
try:
size = item.stat().st_size
if size > 10 * 1024 * 1024: # Only files > 10MB
results["files"].append(
{
"path": str(item),
"name": item.name,
"size_gb": round(size / (1024**3), 2),
"size_mb": round(size / (1024**2), 2),
}
)
except (PermissionError, OSError):
pass
if progress:
progress.update(1, item.name)
if progress:
progress.close()
except (PermissionError, OSError) as e:
print(f"Error scanning {scan_path}: {e}", file=sys.stderr)
return results
def _get_dir_size(self, path: Path, max_depth: int = 1) -> int:
"""Calculate directory size (legacy method, kept for compatibility)"""
total_size = 0
try:
for item in path.rglob("*") if max_depth > 0 else path.iterdir():
if item.is_file() and not item.is_symlink():
try:
total_size += item.stat().st_size
except (PermissionError, OSError):
continue
except (PermissionError, OSError):
pass
return total_size
def _get_dir_size_fast(self, path: Path, max_depth: Optional[int] = None) -> int:
"""
Calculate directory size using os.scandir() for better performance.
This is 3-5x faster than the rglob() method.
Args:
path: Directory to measure.
max_depth: How many directory levels to descend. ``None`` (the
default) walks the whole tree, so the returned size accounts for
deeply nested content. A non-negative int caps the recursion:
``0`` counts only files directly in ``path``, ``1`` also counts
its immediate subdirectories, and so on. Callers that only need a
shallow estimate pass an explicit limit; the directory-ranking
report must not, or large deeply nested trees are undercounted.
"""
total_size = 0
try:
# Use os.scandir() for better performance
with os.scandir(path) as it:
for entry in it:
try:
if entry.is_file(follow_symlinks=False):
total_size += entry.stat().st_size
elif entry.is_dir(follow_symlinks=False) and (
max_depth is None or max_depth > 0
):
# Recursively calculate subdirectory size
next_depth = None if max_depth is None else max_depth - 1
total_size += self._get_dir_size_fast(Path(entry.path), next_depth)
except (PermissionError, OSError):
continue
except (PermissionError, OSError):
pass
return total_size
def get_temp_directories(self) -> List[str]:
"""Get platform-specific temporary directories"""
temp_dirs = []
if self.system == "windows":
temp_dirs = [
os.environ.get("TEMP", ""),
os.environ.get("TMP", ""),
os.path.join(os.environ.get("LOCALAPPDATA", ""), "Temp"),
os.path.join(os.environ.get("TEMP", ""), "..", "Prefetch"),
os.path.join(os.environ.get("WINDIR", ""), "Temp"),
os.path.join(os.environ.get("WINDIR", ""), "Prefetch"),
]
elif self.system == "darwin":
temp_dirs = [
"/tmp",
"/private/tmp",
os.path.expanduser("~/Library/Caches"),
]
else: # Linux
temp_dirs = [
"/tmp",
"/var/tmp",
"/var/cache",
]
# Filter out empty paths, resolve to absolute paths, and deduplicate
seen = set()
unique_dirs = []
for d in temp_dirs:
if d and os.path.exists(d):
# Resolve to real path to handle symlinks and relative paths
real_path = os.path.realpath(d)
if real_path not in seen:
seen.add(real_path)
unique_dirs.append(real_path)
return unique_dirs
def analyze_temp_files(self) -> Dict:
"""Analyze temporary file usage with progress bar"""
temp_dirs = self.get_temp_directories()
results = []
if self.show_progress and len(temp_dirs) > 0:
progress = ProgressBar(len(temp_dirs), prefix="Analyzing temp")
else:
progress = None
for i, temp_dir in enumerate(temp_dirs):
size = self._get_dir_size_fast(Path(temp_dir), max_depth=2)
results.append(
{
"path": temp_dir,
"size_gb": round(size / (1024**3), 2),
"size_mb": round(size / (1024**2), 2),
}
)
if progress:
progress.update(1, Path(temp_dir).name)
if progress:
progress.close()
return {"temp_directories": results}
def find_duplicate_files(self, strategy: str = "adaptive") -> Dict:
"""
Find duplicate files in the scanned directory.
Args:
strategy: Detection strategy ('adaptive', 'fast', 'accurate')
Returns:
Dictionary with duplicate file statistics and details
"""
if not PROGRESS_AVAILABLE or not DuplicateFinder:
return {
"error": "Duplicate finding not available - required modules not loaded",
"duplicates_found": 0,
}
scan_path = Path(self.path)
if not scan_path.exists() or not scan_path.is_dir():
return {
"error": f"Invalid path for duplicate finding: {self.path}",
"duplicates_found": 0,
}
print(f"\n[*] Finding duplicate files in {scan_path}...")
try:
# Collect all files using DirectoryScanner
scanner = DirectoryScanner(
str(scan_path),
max_files=self.max_files,
max_seconds=self.max_seconds,
cache_enabled=False,
)
all_files = []
for file_info in scanner.scan_generator():
if not file_info.is_dir:
all_files.append(file_info)
if not all_files:
return {
"duplicates_found": 0,
"message": "No files found in directory",
}
print(f"[*] Analyzing {len(all_files)} files for duplicates...")
# Find duplicates
finder = DuplicateFinder(strategy=strategy)
duplicates = finder.find_duplicates(all_files)
stats = finder.get_duplicate_stats(duplicates)
# Format results
duplicate_details = []
for group in duplicates[:20]: # Limit to top 20 groups
group_info = {
"count": group.count,
"size_bytes": group.size,
"size_mb": round(group.size / (1024**2), 2),
"reclaimable_bytes": group.reclaimable_space,
"reclaimable_mb": round(group.reclaimable_space / (1024**2), 2),
"files": [f.path for f in group.files],
}
duplicate_details.append(group_info)
return {
"duplicates_found": stats["group_count"],
"total_duplicate_files": stats["file_count"],
"total_size_bytes": stats["total_size"],
"total_size_mb": round(stats["total_size"] / (1024**2), 2),
"reclaimable_bytes": stats["reclaimable"],
"reclaimable_mb": round(stats["reclaimable"] / (1024**2), 2),
"duplicate_groups": duplicate_details,
"strategy_used": strategy,
}
except Exception as e:
return {
"error": f"Error finding duplicates: {str(e)}",
"duplicates_found": 0,
}
def generate_report(self, find_duplicates: bool = False, duplicate_strategy: str = "adaptive") -> Dict:
"""Generate comprehensive analysis report"""
report = {
"timestamp": datetime.now().isoformat(),
"platform": self.platform,
"disk_usage": self.get_disk_usage(),
"temp_analysis": self.analyze_temp_files(),
}
if os.path.isdir(self.path):
report["scan_results"] = self.scan_directory()
# Add duplicate file analysis if requested
if find_duplicates:
report["duplicate_analysis"] = self.find_duplicate_files(strategy=duplicate_strategy)
return report
def print_report(report: Dict):
"""Print formatted report to console"""
print("\n" + "=" * 60)
print(f"DISK SPACE ANALYSIS REPORT - {report['timestamp']}")
print("=" * 60)
# Disk usage
usage = report["disk_usage"]
print(f"\n[i] Disk Usage ({usage['path']}):")
print(f" Total: {usage['total_gb']} GB")
print(f" Used: {usage['used_gb']} GB ({usage['usage_percent']}%)")
print(f" Free: {usage['free_gb']} GB")
# Alert if low on space
if usage["usage_percent"] > 90:
print(" [!] WARNING: Disk critically full!")
elif usage["usage_percent"] > 80:
print(" [!] WARNING: Disk running low on space")
# Temp directories
print("\n[x] Temporary Directories:")
for temp in report["temp_analysis"]["temp_directories"]:
size_str = f"{temp['size_gb']} GB" if temp["size_gb"] > 0 else f"{temp['size_mb']} MB"
print(f" {temp['path']}: {size_str}")
# Large directories
if "scan_results" in report:
print("\n[DIR] Largest Directories:")
for i, d in enumerate(report["scan_results"]["directories"][:10], 1):
size_str = f"{d['size_gb']} GB" if d["size_gb"] > 0 else f"{d['size_mb']} MB"
print(f" {i}. {d['name']}: {size_str}")
print("\n[FILE] Largest Files:")
for i, f in enumerate(report["scan_results"]["files"][:10], 1):
size_str = f"{f['size_gb']} GB" if f["size_gb"] > 0 else f"{f['size_mb']} MB"
print(f" {i}. {f['name']}: {size_str}")
# Duplicate files analysis
if "duplicate_analysis" in report:
dup_analysis = report["duplicate_analysis"]
if "error" in dup_analysis:
print(f"\n[!] Duplicate analysis error: {dup_analysis['error']}")
elif dup_analysis.get("duplicates_found", 0) > 0:
print(f"\n[DUPE] Duplicate Files Found:")
print(f" Groups: {dup_analysis['duplicates_found']}")
print(f" Total files: {dup_analysis['total_duplicate_files']}")
print(f" Total size: {dup_analysis['total_size_mb']:.2f} MB")
print(f" Reclaimable: {dup_analysis['reclaimable_mb']:.2f} MB")
print(f" Strategy: {dup_analysis.get('strategy_used', 'adaptive')}")
# Show top 5 duplicate groups
if "duplicate_groups" in dup_analysis:
print(f"\n Top {min(5, len(dup_analysis['duplicate_groups']))} duplicate groups:")
for i, group in enumerate(dup_analysis["duplicate_groups"][:5], 1):
print(f" {i}. {group['count']} files x {group['size_mb']:.2f} MB")
print(f" Reclaimable: {group['reclaimable_mb']:.2f} MB")
# Show first 2 file paths
for j, path in enumerate(group['files'][:2], 1):
print(f" {j}. {path}")
if len(group['files']) > 2:
print(f" ... and {len(group['files']) - 2} more")
else:
print(f"\n[OK] No duplicate files found")
print("\n" + "=" * 60)
def main():
import argparse
parser = argparse.ArgumentParser(
description="Analyze disk space usage",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
Examples:
# Analyze current drive (C:\\ on Windows, / on Unix)
python scripts/analyze_disk.py
# Analyze specific path with default limits
python scripts/analyze_disk.py --path "D:/Projects"
# Analyze with custom limits for large drives
python scripts/analyze_disk.py --path "D:/" --file-limit 2000000 --time-limit 600
# Get top 50 largest items
python scripts/analyze_disk.py --top 50
# Output as JSON for automation
python scripts/analyze_disk.py --json --output report.json
""",
)
parser.add_argument("--path", "-p", help="Path to analyze", default=None)
parser.add_argument("--top", "-n", type=int, default=20, help="Number of top items to show")
parser.add_argument(
"--file-limit",
type=int,
default=None,
help="Maximum number of files to scan (default: 500000 for large disks)",
)
parser.add_argument(
"--time-limit",
type=int,
default=None,
help="Maximum scan time in seconds (default: 120 for large disks)",
)
parser.add_argument(
"--sample",
action="store_true",
help="Quick sample mode (1 second) to estimate scan time and directory characteristics",
)
parser.add_argument(
"--progressive",
action="store_true",
help="Use progressive scanning with real-time feedback (recommended for large disks)",
)
parser.add_argument("--json", action="store_true", help="Output as JSON")
parser.add_argument("--output", "-o", help="Save report to file")
parser.add_argument(
"--deep-scan",
action="store_true",
help="Deep scan mode: removes all file and time limits for complete disk analysis",
)
parser.add_argument(
"--include-windows",
action="store_true",
help="Include Windows system directories (C:\\Windows, Program Files, etc.) in scan",
)
parser.add_argument(
"--no-progress", action="store_true", help="Disable progress bars (useful for scripting)"
)
parser.add_argument(
"--find-duplicates",
action="store_true",
help="Find duplicate files during analysis",
)
parser.add_argument(
"--duplicate-strategy",
choices=["adaptive", "fast", "accurate"],
default="adaptive",
help="Duplicate detection strategy (default: adaptive)",
)
args = parser.parse_args()
# Handle deep scan parameters
if args.deep_scan:
file_limit = None # No limit
time_limit = None # No limit
print("[i] Deep scan mode: All limits removed")
else:
file_limit = args.file_limit
time_limit = args.time_limit
show_progress = not args.no_progress and not args.json
analyzer = DiskAnalyzer(
path=args.path,
top_n=args.top,
show_progress=show_progress,
max_files=file_limit,
max_seconds=time_limit,
include_windows=args.include_windows,
)
# Quick sample mode
if args.sample:
sample_result = analyzer.quick_sample(sample_time=1.0)
if args.json:
print(json.dumps(sample_result, indent=2))
sys.exit(0)
# For potentially large disks, sample first and ask
if not args.json and not args.sample and not args.progressive:
# Automatically perform 1-second sampling
sample_result = analyzer.quick_sample(sample_time=1.0)
estimated_time = sample_result.get("estimated_time_seconds", 0)
# If estimated over 2 minutes, recommend using limits
if estimated_time > 120:
print(f"\n[!] Estimated full scan time: {estimated_time/60:.1f} minutes")
print("\n[i] Recommended options:")
print(" --sample Quick sample mode (1 second)")
print(" --file-limit 10000 Limit file count")
print(" --time-limit 30 Limit time (seconds)")
print(" --progressive Progressive scanning")
print("\nTo continue full scan, press Ctrl+C and re-run with appropriate parameters")
report = analyzer.generate_report(
find_duplicates=args.find_duplicates,
duplicate_strategy=args.duplicate_strategy,
)
if args.json:
print(json.dumps(report, indent=2))
else:
print_report(report)
if args.output:
with open(args.output, "w") as f:
json.dump(report, f, indent=2)
print(f"\n[OK] Report saved to {args.output}")
if __name__ == "__main__":
main()
scripts/analyze_growth.py
#!/usr/bin/env python3
"""
Disk Growth Analyzer - Track and analyze disk space growth trends
This script analyzes disk usage over time to:
- Calculate growth rates (daily, weekly, monthly)
- Predict when disk will be full
- Identify unusual growth patterns
- Generate trend reports
Features:
- JSON-based historical data storage
- ASCII-safe output
- Cross-platform compatibility
- Progress bars for large operations
"""
import argparse
import json
import os
import platform
import sys
from datetime import datetime
from pathlib import Path
from typing import Dict
# Add parent directory to path for imports
script_dir = Path(__file__).parent.parent
if str(script_dir) not in sys.path:
sys.path.insert(0, str(script_dir))
try:
from diskcleaner.core.growth_analyzer import GrowthAnalyzer, format_size
from diskcleaner.core.progress import ProgressBar
PROGRESS_AVAILABLE = True
except ImportError:
print("Warning: diskcleaner modules not available", file=sys.stderr)
PROGRESS_AVAILABLE = False
def capture_snapshot(path: str, analyzer: GrowthAnalyzer) -> Dict:
"""
Capture current disk usage snapshot.
Args:
path: Path to analyze
analyzer: GrowthAnalyzer instance
Returns:
Snapshot dictionary
"""
print(f"\n[*] Capturing disk usage snapshot for {path}...")
# Get disk usage
try:
if hasattr(os, 'statvfs'):
# Unix-like systems
stat = os.statvfs(path)
total_bytes = stat.f_frsize * stat.f_blocks
free_bytes = stat.f_frsize * stat.f_bavail
used_bytes = total_bytes - free_bytes
else:
# Windows
import ctypes
total_bytes = ctypes.c_ulonglong(0)
free_bytes = ctypes.c_ulonglong(0)
ctypes.windll.kernel32.GetDiskFreeSpaceExW(
ctypes.c_wchar_p(path),
None,
ctypes.byref(total_bytes),
ctypes.byref(free_bytes),
)
total_bytes = total_bytes.value
free_bytes = free_bytes.value
used_bytes = total_bytes - free_bytes
# Create metadata
metadata = {
"platform": platform.system(),
"hostname": platform.node(),
}
# Add snapshot to history
success = analyzer.add_snapshot(
path=path,
used_bytes=used_bytes,
total_bytes=total_bytes,
free_bytes=free_bytes,
metadata=metadata,
)
if success:
print(f"[OK] Snapshot captured successfully")
print(f" Total: {format_size(total_bytes)}")
print(f" Used: {format_size(used_bytes)} ({used_bytes/total_bytes*100:.1f}%)")
print(f" Free: {format_size(free_bytes)}")
return {
"path": path,
"used_bytes": used_bytes,
"total_bytes": total_bytes,
"free_bytes": free_bytes,
"used_percent": round((used_bytes / total_bytes * 100), 2),
}
else:
print("[!] Failed to save snapshot")
return {"error": "Failed to save snapshot"}
except Exception as e:
print(f"[!] Error capturing snapshot: {e}")
return {"error": str(e)}
def print_growth_report(report: Dict):
"""
Print formatted growth analysis report.
Args:
report: Report dictionary from generate_report()
"""
print("\n" + "=" * 80)
print("DISK GROWTH ANALYSIS REPORT")
print("=" * 80)
if "error" in report:
print(f"\n[!] Error: {report['error']}")
if "message" in report:
print(f"[*] {report['message']}")
print("\n" + "=" * 80)
return
# Basic info
print(f"\n[*] Analysis Date: {report['analysis_date']}")
print(f"[*] Path: {report['path']}")
print(f"[*] Data Points: {report['snapshots_count']} snapshots")
print(f"[*] Date Range: {report['date_range']['earliest']} to {report['date_range']['latest']}")
# Latest snapshot
latest = report['latest_snapshot']
print(f"\n[*] Current Usage:")
print(f" Total: {format_size(latest['total_bytes'])}")
print(f" Used: {format_size(latest['used_bytes'])} ({latest['used_percent']:.1f}%)")
print(f" Free: {format_size(latest['free_bytes'])}")
# Growth rates
print(f"\n[*] Growth Rates:")
for period in ['daily', 'weekly', 'monthly']:
rate_data = report['growth_rates'][period]
if 'error' not in rate_data:
period_name = period.capitalize()
growth_mb = rate_data['avg_growth_mb_per_period']
growth_gb = rate_data['avg_growth_gb_per_period']
# Use appropriate unit
if growth_gb >= 0.01:
growth_str = f"{growth_gb:.2f} GB"
else:
growth_str = f"{growth_mb:.2f} MB"
print(f" {period_name}: {growth_str} / {period}")
# Show trend if available
if 'trend' in rate_data:
trend = rate_data['trend']
if trend == 'accelerating':
print(f" Trend: Accelerating (+)")
elif trend == 'decelerating':
print(f" Trend: Decelerating (-)")
else:
print(f" Trend: Stable")
# Prediction
prediction = report['prediction']
if 'error' not in prediction:
print(f"\n[*] Prediction:")
if 'message' in prediction:
print(f" {prediction['message']}")
else:
daily_growth_mb = prediction['daily_growth_mb']
daily_growth_gb = prediction['daily_growth_gb']
if daily_growth_gb >= 0.01:
growth_str = f"{daily_growth_gb:.2f} GB"
else:
growth_str = f"{daily_growth_mb:.2f} MB"
print(f" Daily growth: {growth_str}")
print(f" Days until full: {prediction['days_until_full']:.0f}")
if prediction['days_until_full'] < 30:
print(f" [!] WARNING: Disk will be full on {prediction['predicted_full_date_human']}")
print(f" ({prediction['weeks_until_full']:.1f} weeks)")
elif prediction['days_until_full'] < 90:
print(f" [!] Caution: Disk will be full on {prediction['predicted_full_date_human']}")
print(f" ({prediction['months_until_full']:.1f} months)")
else:
print(f" Estimated full date: {prediction['predicted_full_date_human']}")
print(f" ({prediction['months_until_full']:.1f} months)")
# Warnings
if latest['used_percent'] > 90:
print(f"\n[!] CRITICAL: Disk is {latest['used_percent']:.1f}% full!")
elif latest['used_percent'] > 80:
print(f"\n[!] WARNING: Disk is {latest['used_percent']:.1f}% full")
print("\n" + "=" * 80)
def print_history(snapshots: list, limit: int = 20):
"""
Print historical snapshots.
Args:
snapshots: List of snapshot dictionaries
limit: Maximum number to show
"""
if not snapshots:
print("\n[*] No historical data available")
return
print(f"\n[*] Historical Data (showing last {min(limit, len(snapshots))} of {len(snapshots)} snapshots):")
print("-" * 80)
for snapshot in snapshots[-limit:]:
timestamp = snapshot['timestamp']
used_percent = snapshot['used_percent']
used_mb = snapshot['used_bytes'] / (1024**2)
print(f" {timestamp}: {used_percent:.1f}% used ({used_mb:.0f} MB)")
print("-" * 80)
def main():
"""Main entry point"""
# Fix Windows console encoding
if sys.platform == "win32":
import codecs
sys.stdout = codecs.getwriter("utf-8")(sys.stdout.buffer, "strict")
sys.stderr = codecs.getwriter("utf-8")(sys.stderr.buffer, "strict")
parser = argparse.ArgumentParser(
description="Analyze disk space growth trends",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
Examples:
# Capture a snapshot and analyze growth
python scripts/analyze_growth.py --capture
# Analyze existing growth data
python scripts/analyze_growth.py
# Analyze specific path
python scripts/analyze_growth.py --path "/home"
# Show historical data
python scripts/analyze_growth.py --history
# Capture snapshot without analysis
python scripts/analyze_growth.py --capture --no-analyze
# Use custom data file
python scripts/analyze_growth.py --data-file /path/to/growth.json
# Clean up old data (keep last year)
python scripts/analyze_growth.py --cleanup 365
""",
)
parser.add_argument(
"--path",
"-p",
default=None,
help="Path to analyze (default: auto-detect)",
)
parser.add_argument(
"--capture",
action="store_true",
help="Capture current disk usage snapshot",
)
parser.add_argument(
"--no-analyze",
action="store_true",
help="Skip analysis after capturing (only useful with --capture)",
)
parser.add_argument(
"--history",
action="store_true",
help="Show historical snapshot data",
)
parser.add_argument(
"--data-file",
help="Path to JSON file for storing data (default: ~/.diskcleaner/growth_history.json)",
)
parser.add_argument(
"--cleanup",
type=int,
metavar="DAYS",
help="Remove snapshots older than N days",
)
parser.add_argument(
"--json",
action="store_true",
help="Output as JSON instead of human-readable",
)
parser.add_argument(
"--output",
"-o",
help="Save report to file (JSON format)",
)
args = parser.parse_args()
# Initialize analyzer
try:
analyzer = GrowthAnalyzer(data_file=args.data_file)
print(f"[*] Data file: {analyzer.data_file}")
except Exception as e:
print(f"[!] Error initializing analyzer: {e}", file=sys.stderr)
sys.exit(2)
# Capture snapshot if requested
if args.capture:
# Determine path
if args.path:
path = args.path
else:
# Auto-detect default path
system = platform.system()
if system == "Windows":
path = "C:\\"
elif system == "Darwin": # macOS
path = "/"
else: # Linux
path = "/"
snapshot = capture_snapshot(path, analyzer)
if "error" in snapshot:
sys.exit(2)
# Skip analysis if requested
if args.no_analyze:
print("[OK] Snapshot captured, analysis skipped")
sys.exit(0)
# Cleanup old data if requested
if args.cleanup:
removed = analyzer.cleanup_old_data(days=args.cleanup)
print(f"[OK] Removed {removed} old snapshots")
sys.exit(0)
# Show history if requested
if args.history:
snapshots = analyzer.get_snapshots(path=args.path)
print_history(snapshots, limit=50)
sys.exit(0)
# Generate and display report
if not args.capture and not args.history and not args.cleanup:
print("[*] Analyzing growth trends...")
report = analyzer.generate_report(path=args.path)
if args.json:
print(json.dumps(report, indent=2))
else:
print_growth_report(report)
# Save to file if requested
if args.output:
with open(args.output, "w", encoding="utf-8") as f:
json.dump(report, f, indent=2)
print(f"\n[OK] Report saved to {args.output}")
# Exit code based on disk usage
if "error" not in report and "latest_snapshot" in report:
usage_percent = report["latest_snapshot"]["used_percent"]
if usage_percent > 90:
sys.exit(2) # Critical
elif usage_percent > 80:
sys.exit(1) # Warning
else:
sys.exit(0) # OK
else:
sys.exit(0)
if __name__ == "__main__":
main()
scripts/analyze_progressive.py
#!/usr/bin/env python3
"""
Progressive Disk Analyzer
Analysis tool optimized for large disks:
1. Quick sampling estimation (0.5-1 second)
2. Display estimated scan time
3. Progressive result display
4. Can interrupt anytime to view partial results
"""
import argparse
import json
import os
import sys
import time
from datetime import datetime
from pathlib import Path
from typing import Dict, List, Optional
# Use smart bootstrap module import
try:
script_dir = Path(__file__).parent.resolve()
if str(script_dir) not in sys.path:
sys.path.insert(0, str(script_dir))
from skill_bootstrap import init_console, safe_print, setup_skill_environment
# Initialize console encoding
init_console()
_, bootstrap = setup_skill_environment(require_modules=False)
IMPORT_SUCCESS, MODULES = bootstrap.import_diskcleaner_modules()
if IMPORT_SUCCESS:
DirectoryScanner = MODULES.get("DirectoryScanner")
Config = MODULES.get("Config")
else:
DirectoryScanner = None
Config = None
except Exception as e:
safe_print(f"Warning: Import failed - {e}")
DirectoryScanner = None
Config = None
class ProgressiveDiskAnalyzer:
"""Progressive disk analyzer - provides real-time feedback and early results"""
def __init__(self, target_path: str = None):
self.target_path = Path(target_path or self._get_default_path()).resolve()
self.platform = sys.platform
self.results_shown = 0
self.start_time = None
self.last_update_time = 0
def _get_default_path(self) -> str:
"""Get default scan path"""
if sys.platform == "Windows":
return "C:\\"
else:
return "/"
def quick_sample(self, sample_time: float = 1.0) -> Dict:
"""
Quick sampling analysis - estimate directory characteristics within 1 second
Returns:
Dictionary containing estimation information
"""
safe_print(f"\n[*] Quick sampling analysis... ({sample_time}s)")
file_count = 0
total_size = 0
sample_dirs = 0
start = time.time()
try:
# Use os.scandir for quick sampling
for root, dirs, files in os.walk(str(self.target_path)):
if time.time() - start > sample_time:
break
sample_dirs += len(dirs)
file_count += len(files)
# Sample file sizes (max 100)
for i, f in enumerate(files[:100]):
try:
file_path = Path(root) / f
if file_path.is_file():
total_size += file_path.stat().st_size
except (OSError, PermissionError):
pass
except Exception as e:
safe_print(f"Sampling error: {e}")
elapsed = time.time() - start
# Calculate estimates
if elapsed > 0:
files_per_second = file_count / elapsed
else:
files_per_second = 0
# Estimate total time (2x safety margin)
if files_per_second > 0:
estimated_seconds = (file_count / files_per_second) * 2
else:
estimated_seconds = 0
result = {
"sample_file_count": file_count,
"sample_size_gb": round(total_size / (1024**3), 2),
"sample_dirs": sample_dirs,
"files_per_second": round(files_per_second, 0),
"estimated_time_seconds": round(estimated_seconds, 1),
}
# Display sampling results
safe_print("\n[i] Sampling results:")
safe_print(f" Files found: {file_count:,}")
safe_print(f" Directories: {sample_dirs:,}")
safe_print(f" Scan speed: {result['files_per_second']:,} files/sec")
if estimated_seconds > 0:
if estimated_seconds < 60:
safe_print(f" Estimated full scan: {estimated_seconds:.0f} seconds")
else:
safe_print(f" Estimated full scan: {estimated_seconds/60:.1f} minutes")
return result
def progressive_scan(
self, max_files: int = None, max_seconds: int = None, show_progress: bool = True
) -> Dict:
"""
Progressive scan - display results in real-time
Args:
max_files: Maximum file count limit
max_seconds: Maximum time limit (seconds)
show_progress: Whether to show progress
Returns:
Scan result dictionary
"""
if DirectoryScanner is None:
safe_print("[X] Advanced scanning not available, using basic method")
return self._basic_scan()
# Set limits
if max_files is None:
max_files = 50000 # Default 50k files
if max_seconds is None:
max_seconds = 30 # Default 30 seconds
safe_print("\n[*] Progressive scan started")
safe_print(f" Limits: {max_files:,} files or {max_seconds} seconds")
safe_print(" Press Ctrl+C anytime to interrupt and view partial results\n")
self.start_time = time.time()
results = {"directories": [], "files": [], "scanned": 0}
try:
scanner = DirectoryScanner(
str(self.target_path),
max_files=max_files,
max_seconds=max_seconds,
cache_enabled=False,
)
# Use generator for progressive processing
file_count = 0
last_display_time = 0
display_interval = 2.0 # Display progress every 2 seconds
for file_info in scanner.scan_generator():
file_count += 1
elapsed = time.time() - self.start_time
# Progressive progress display
if show_progress and elapsed - last_display_time > display_interval:
self._show_progress(file_count, elapsed, scanner.stopped_early)
last_display_time = elapsed
# Collect large files (>10MB)
if not file_info.is_dir and file_info.size > 10 * 1024 * 1024:
results["files"].append(
{
"path": file_info.path,
"name": file_info.name,
"size_gb": round(file_info.size / (1024**3), 2),
"size_mb": round(file_info.size / (1024**2), 2),
}
)
# Collect directories (top-level only)
if file_info.is_dir and Path(file_info.path).parent == self.target_path:
results["directories"].append(
{
"path": file_info.path,
"name": file_info.name,
}
)
# Scan complete
elapsed = time.time() - self.start_time
self._show_progress(file_count, elapsed, True)
# Calculate directory sizes
results["directories"] = self._calculate_dir_sizes(results["directories"][:20])
# Sort and limit result count
results["files"].sort(key=lambda x: x["size_gb"], reverse=True)
results["directories"].sort(key=lambda x: x["size_gb"], reverse=True)
results["files"] = results["files"][:50]
results["directories"] = results["directories"][:50]
# Add scan information
results["scan_info"] = {
"files_scanned": file_count,
"scan_time_seconds": round(elapsed, 1),
"stopped_early": scanner.stopped_early,
"stop_reason": scanner.stop_reason if scanner.stopped_early else "",
}
except KeyboardInterrupt:
safe_print("\n\n[!] Scan interrupted by user")
elapsed = time.time() - self.start_time
safe_print(f" Scanned: {results.get('scanned', 0):,} files")
safe_print(f" Time: {elapsed:.1f} seconds")
except Exception as e:
safe_print(f"\n[X] Scan error: {e}")
return self._basic_scan()
return results
def _show_progress(self, file_count: int, elapsed: float, complete: bool = False):
"""Display scan progress"""
if complete:
safe_print(f"\n[OK] Scan complete: {file_count:,} files, {elapsed:.1f} seconds")
else:
safe_print(f" Scanning: {file_count:,} files, {elapsed:.1f} seconds... (continuing)")
def _calculate_dir_sizes(self, dirs: List[Dict], max_depth: int = 1) -> List[Dict]:
"""Calculate directory sizes"""
results = []
for dir_info in dirs:
dir_path = Path(dir_info["path"])
try:
size = self._get_dir_size_fast(dir_path, max_depth)
if size > 0:
results.append(
{
**dir_info,
"size_gb": round(size / (1024**3), 2),
"size_mb": round(size / (1024**2), 2),
}
)
except (PermissionError, OSError):
pass
return results
def _get_dir_size_fast(self, path: Path, max_depth: int = 1) -> int:
"""Fast directory size calculation"""
total_size = 0
try:
with os.scandir(path) as it:
for entry in it:
try:
if entry.is_file(follow_symlinks=False):
total_size += entry.stat().st_size
elif entry.is_dir(follow_symlinks=False) and max_depth > 0:
total_size += self._get_dir_size_fast(Path(entry.path), max_depth - 1)
except (PermissionError, OSError):
continue
except (PermissionError, OSError):
pass
return total_size
def _basic_scan(self) -> Dict:
"""Basic scan method (when advanced features unavailable)"""
safe_print("\nUsing basic scan method...")
results = {"directories": [], "files": []}
file_count = 0
try:
# Only scan top level
for item in self.target_path.iterdir():
if item.is_dir() and not item.is_symlink():
try:
size = self._get_dir_size_fast(item, max_depth=1)
if size > 1024 * 1024: # > 1MB
results["directories"].append(
{
"path": str(item),
"name": item.name,
"size_gb": round(size / (1024**3), 2),
"size_mb": round(size / (1024**2), 2),
}
)
except (PermissionError, OSError):
pass
file_count += 1
elif item.is_file():
try:
size = item.stat().st_size
if size > 10 * 1024 * 1024: # > 10MB
results["files"].append(
{
"path": str(item),
"name": item.name,
"size_gb": round(size / (1024**3), 2),
"size_mb": round(size / (1024**2), 2),
}
)
except (PermissionError, OSError):
pass
file_count += 1
except Exception as e:
safe_print(f"Basic scan also failed: {e}")
results["directories"].sort(key=lambda x: x["size_gb"], reverse=True)
results["files"].sort(key=lambda x: x["size_gb"], reverse=True)
results["scan_info"] = {
"files_scanned": file_count,
"scan_time_seconds": 0,
"stopped_early": False,
"stop_reason": "",
}
return results
def format_report(self, results: Dict) -> str:
"""Format report"""
lines = []
lines.append("\n" + "=" * 60)
lines.append(f"DISK ANALYSIS REPORT - {self.target_path}")
lines.append("=" * 60)
# Scan info
if "scan_info" in results:
info = results["scan_info"]
lines.append("\n[i] Scan Info:")
lines.append(f" Files scanned: {info.get('files_scanned', 0):,}")
lines.append(f" Time: {info.get('scan_time_seconds', 0):.1f} seconds")
if info.get("stopped_early"):
lines.append(f" Stopped early: {info.get('stop_reason', 'Unknown')}")
# Large directories
if results.get("directories"):
lines.append("\n[DIR] Largest Directories:")
for i, d in enumerate(results["directories"][:20], 1):
size_str = f"{d['size_gb']} GB" if d["size_gb"] > 0 else f"{d['size_mb']} MB"
lines.append(f" {i}. {d['name']}: {size_str}")
# Large files
if results.get("files"):
lines.append("\n[FILE] Largest Files:")
for i, f in enumerate(results["files"][:20], 1):
size_str = f"{f['size_gb']} GB" if f["size_gb"] > 0 else f"{f['size_mb']} MB"
# Shorten path
path_str = f"...{f['path'][-50:]}" if len(f["path"]) > 50 else f["path"]
lines.append(f" {i}. {f['name']}: {size_str}")
lines.append(f" {path_str}")
lines.append("\n" + "=" * 60)
return "\n".join(lines)
def main():
import argparse
parser = argparse.ArgumentParser(
description="Progressive disk analyzer - suitable for large disks",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
Examples:
# Quick sampling (1 second)
python scripts/analyze_progressive.py --sample
# Progressive scan (30 second limit)
python scripts/analyze_progressive.py --max-seconds 30
# Limit file count (fast)
python scripts/analyze_progressive.py --max-files 10000
# Full scan (long time)
python scripts/analyze_progressive.py --max-seconds 300
# Custom path
python scripts/analyze_progressive.py --path "D:\\Projects" --sample
""",
)
parser.add_argument("--path", "-p", help="Scan path")
parser.add_argument("--sample", action="store_true", help="Quick sample only (1 second)")
parser.add_argument(
"--max-files", type=int, default=50000, help="Maximum file count limit (default: 50000)"
)
parser.add_argument("--max-seconds", type=int, default=30, help="Maximum time limit-seconds (default: 30)")
parser.add_argument("--json", action="store_true", help="JSON output")
parser.add_argument("--no-progress", action="store_true", help="Disable progress")
args = parser.parse_args()
analyzer = ProgressiveDiskAnalyzer(args.path)
# Quick sample mode
if args.sample:
sample_result = analyzer.quick_sample(sample_time=1.0)
if args.json:
print(json.dumps(sample_result, indent=2))
return 0
# Perform quick sampling first
sample_result = analyzer.quick_sample(sample_time=1.0)
# Ask whether to continue
estimated_time = sample_result.get("estimated_time_seconds", 0)
if estimated_time > 60: # Over 1 minute
safe_print(f"\n[!] Estimated scan time: {estimated_time/60:.1f} minutes")
safe_print("Recommendations:")
safe_print(" 1. Use --sample for quick sample mode")
safe_print(" 2. Use --max-seconds to reduce time limit")
safe_print(" 3. Use --max-files to limit file count")
# Non-interactive mode, return directly
if args.json:
print(json.dumps({"sample": sample_result}, indent=2))
return 0
# Progressive scan
results = analyzer.progressive_scan(
max_files=args.max_files, max_seconds=args.max_seconds, show_progress=not args.no_progress
)
if args.json:
print(json.dumps(results, indent=2, ensure_ascii=False))
else:
print(analyzer.format_report(results))
return 0
if __name__ == "__main__":
try:
sys.exit(main())
except KeyboardInterrupt:
safe_print("\n\n[*] User interrupted")
sys.exit(0)
scripts/check_skill.py
#!/usr/bin/env python3
"""
Disk Cleaner Skill Package Diagnostic Tool
Quickly detect if skill package is working correctly and provide detailed diagnostic information.
"""
import os
import platform
import sys
from pathlib import Path
# Initialize Windows console encoding
def init_console():
"""Initialize console encoding"""
if platform.system().lower() == "windows":
try:
import ctypes
ctypes.windll.kernel32.SetConsoleOutputCP(65001)
if hasattr(sys.stdout, "buffer"):
import io
sys.stdout = io.TextIOWrapper(
sys.stdout.buffer, encoding="utf-8", errors="replace", line_buffering=True
)
if hasattr(sys.stderr, "buffer"):
sys.stderr = io.TextIOWrapper(
sys.stderr.buffer, encoding="utf-8", errors="replace", line_buffering=True
)
except Exception:
pass
# Initialize at module load time
init_console()
def print_section(title: str):
"""Print section title"""
print(f"\n{'='*60}")
print(f" {title}")
print("=" * 60)
def print_check(name: str, status: bool, details: str = ""):
"""Print check result"""
icon = "[OK]" if status else "[X]"
print(f"{icon} {name}")
if details:
print(f" {details}")
def check_python_version():
"""Check Python version"""
version = sys.version_info
version_str = f"{version.major}.{version.minor}.{version.micro}"
# Python 3.7+ is recommended
is_good = version >= (3, 7)
is_excellent = version >= (3, 8)
if is_excellent:
print_check("Python Version", True, f"v{version_str} (recommended)")
elif is_good:
print_check("Python Version", True, f"v{version_str} (usable, recommend upgrading to 3.8+)")
else:
print_check("Python Version", False, f"v{version_str} (requires 3.7+)")
return is_good
def check_platform():
"""Check operating system"""
system = platform.system()
version = platform.version()
print_check("Operating System", True, f"{system} {platform.release()}")
return True
def check_skill_structure():
"""Check skill package file structure"""
print("\n[DIR] Checking skill package file structure:")
# Detect skill root
script_dir = Path(__file__).parent.resolve()
skill_root = script_dir.parent
if not skill_root.exists():
print_check("Skill Root", False, f"Not found: {skill_root}")
return False
print_check("Skill Root", True, str(skill_root))
# Check key files
key_files = [
("SKILL.md", "Skill documentation"),
("scripts/analyze_disk.py", "Disk analysis script"),
("scripts/clean_disk.py", "Cleaning script"),
("scripts/monitor_disk.py", "Monitoring script"),
("scripts/skill_bootstrap.py", "Bootstrap module"),
("diskcleaner/__init__.py", "Core module"),
("diskcleaner/core/progress.py", "Progress bar module"),
("diskcleaner/core/scanner.py", "Scanner module"),
]
all_ok = True
for file_path, description in key_files:
full_path = skill_root / file_path
exists = full_path.exists()
print_check(f" {description}", exists, file_path if exists else "missing")
if not exists:
all_ok = False
return all_ok
def check_imports():
"""Check module imports"""
print("\n[PKG] Checking module imports:")
# First check bootstrap module
try:
script_dir = Path(__file__).parent.resolve()
if str(script_dir) not in sys.path:
sys.path.insert(0, str(script_dir))
from skill_bootstrap import get_bootstrap
bootstrap = get_bootstrap()
print_check(" Bootstrap Module", True, "skill_bootstrap.py")
except ImportError as e:
print_check(" Bootstrap Module", False, f"Import failed: {e}")
return False
# Setup environment
success = bootstrap.setup_import_path()
print_check(" Environment Setup", success, "Module path configured" if success else "Path configuration failed")
if not success:
return False
# Try importing core modules
modules = [
("diskcleaner", "Main module"),
("diskcleaner.config", "Config module"),
("diskcleaner.core.progress", "Progress bar"),
("diskcleaner.core.scanner", "Scanner"),
]
all_ok = True
for module_name, description in modules:
try:
__import__(module_name)
print_check(f" {description}", True, module_name)
except ImportError as e:
print_check(f" {description}", False, f"{module_name}: {e}")
all_ok = False
return all_ok
def check_permissions():
"""Check file permissions"""
print("\n[KEY] Checking file permissions:")
# Check if have permission to create temp files
try:
import tempfile
with tempfile.NamedTemporaryFile(mode="w", delete=True) as f:
f.write("test")
print_check("Temp File Creation", True)
except Exception as e:
print_check("Temp File Creation", False, str(e))
return False
# Check directory read permission
script_dir = Path(__file__).parent.resolve()
try:
list(script_dir.iterdir())
print_check("Directory Read Permission", True)
except Exception as e:
print_check("Directory Read Permission", False, str(e))
return False
return True
def check_scripts():
"""Test if scripts can run"""
print("\n[TEST] Testing script execution:")
script_dir = Path(__file__).parent.resolve()
scripts = [
"analyze_disk.py",
"clean_disk.py",
"monitor_disk.py",
]
all_ok = True
for script_name in scripts:
script_path = script_dir / script_name
if not script_path.exists():
print_check(f" {script_name}", False, "File does not exist")
all_ok = False
continue
# Try compiling script (check syntax)
try:
with open(script_path, "r", encoding="utf-8") as f:
compile(f.read(), str(script_path), "exec")
print_check(f" {script_name}", True, "Syntax check passed")
except SyntaxError as e:
print_check(f" {script_name}", False, f"Syntax error: {e}")
all_ok = False
except Exception as e:
print_check(f" {script_name}", False, f"Check failed: {e}")
all_ok = False
return all_ok
def main():
"""Main diagnostic flow"""
print_section("DISK CLEANER SKILL PACKAGE DIAGNOSTIC TOOL")
print(f"Time: {__import__('datetime').datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
results = []
# Execute various checks
print_section("Environment Check")
results.append(("Python Version", check_python_version()))
results.append(("Operating System", check_platform()))
results.append(("File Structure", check_skill_structure()))
results.append(("Module Import", check_imports()))
results.append(("File Permissions", check_permissions()))
results.append(("Script Test", check_scripts()))
# Summary
print_section("Diagnostic Summary")
passed = sum(1 for _, result in results if result)
total = len(results)
print(f"\nPassed: {passed}/{total}")
for name, result in results:
icon = "[OK]" if result else "[X]"
print(f"{icon} {name}")
if passed == total:
print("\n[*] All checks passed! Skill package can be used normally.")
return 0
else:
print(f"\n[!] Found {total - passed} issue(s) that need to be resolved.")
# Provide fix suggestions
print_section("Fix Suggestions")
if not results[2][1]: # File structure failed
print("\n[X] File structure issues:")
print(" Ensure skill package is correctly extracted with the following structure:")
print(" disk-cleaner/")
print(" ├── SKILL.md")
print(" ├── scripts/")
print(" │ ├── analyze_disk.py")
print(" │ ├── clean_disk.py")
print(" │ ├── monitor_disk.py")
print(" │ └── skill_bootstrap.py")
print(" └── diskcleaner/")
if not results[3][1]: # Module import failed
print("\n[X] Module import issues:")
print(" Try the following methods:")
print(" 1. Run: python scripts/skill_bootstrap.py --test-import")
print(" 2. Set PYTHONPATH environment variable")
print(" 3. Run scripts from skill package root directory")
if not results[5][1]: # Script test failed
print("\n[X] Script issues:")
print(" Check if Python syntax is correct")
print(" Ensure file encoding is UTF-8")
return 1
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser(description="Diagnose Disk Cleaner skill package")
parser.add_argument("--verbose", "-v", action="store_true", help="Show detailed information")
parser.add_argument("--fix", action="store_true", help="Try to automatically fix issues")
args = parser.parse_args()
# Set debug mode
if args.verbose:
os.environ["DISK_CLEANER_DEBUG"] = "true"
sys.exit(main())
scripts/clean_disk.py
#!/usr/bin/env python3
"""
Disk Cleaner - Cross-platform junk file cleaner
Safely removes temporary files, caches, logs, and other junk files
Enhanced with progress bars for better user feedback.
"""
import json
import os
import platform
import shutil
import stat
import sys
from datetime import datetime, timedelta
from pathlib import Path
from typing import Dict, List, Optional, Set, Tuple
# Use smart bootstrap module to import diskcleaner
try:
# Add parent directory of current script to path for importing skill_bootstrap
script_dir = Path(__file__).parent.resolve()
if str(script_dir) not in sys.path:
sys.path.insert(0, str(script_dir))
from skill_bootstrap import import_diskcleaner_modules
# Setup skill environment and import modules
IMPORT_SUCCESS, MODULES = import_diskcleaner_modules()
PROGRESS_AVAILABLE = IMPORT_SUCCESS
if IMPORT_SUCCESS:
ProgressBar = MODULES["ProgressBar"]
else:
ProgressBar = None
except Exception as e:
# If bootstrap module also fails, try direct import (may be installed)
try:
from diskcleaner.core.progress import ProgressBar
PROGRESS_AVAILABLE = True
print(f"[Warning] Skill bootstrap failed, using installed version: {e}", file=sys.stderr)
except ImportError:
PROGRESS_AVAILABLE = False
ProgressBar = None
print(
f"[Warning] Cannot import diskcleaner module, some features unavailable: {e}",
file=sys.stderr,
)
JUNK_DIRECTORY_NAMES = {
"$recycle.bin",
"cache",
"caches",
"cookies",
"downloads",
"history",
"inetcache",
"log",
"logs",
"prefetch",
"recycle",
"recycler",
"temp",
"temporary",
"tmp",
"trash",
"webcache",
}
PROJECT_MARKERS = {
".git",
".hg",
".svn",
"Cargo.toml",
"go.mod",
"package.json",
"pyproject.toml",
}
class UnsafePathError(ValueError):
"""A custom cleanup target failed validation."""
class DiskCleaner:
def __init__(self, dry_run: bool = True, show_progress: bool = True):
self.dry_run = dry_run
self.platform = platform.system()
self.system = platform.system().lower()
self.cleaned_files = []
self.freed_space = 0
self.errors = []
self.show_progress = show_progress and PROGRESS_AVAILABLE and sys.stdout.isatty()
# Safety: paths to never delete
self.protected_paths = self._get_protected_paths()
# Safety: file extensions to never delete
self.protected_extensions = {
".exe",
".dll",
".sys",
".drv",
".bat",
".cmd",
".ps1",
".sh",
".bash",
".zsh",
".app",
".dmg",
".pkg",
".deb",
".rpm",
".msi",
".iso",
".vhd",
".vhdx",
}
def _get_protected_paths(self) -> Set[str]:
"""Get paths that should never be deleted"""
protected = set()
if self.system == "windows":
protected.update(
[
"C:\\Windows",
"C:\\Program Files",
"C:\\Program Files (x86)",
"C:\\ProgramData",
]
)
# Protect user profile root but NOT subdirectories (allows cleaning Temp, Cache, etc.)
# We use a trailing separator to indicate we're protecting the directory itself,
# not its contents
# if "USERPROFILE" in os.environ:
# protected.add(os.environ["USERPROFILE"])
elif self.system == "darwin":
protected.update(
[
"/System",
"/Library",
"/Applications",
"/usr",
"/bin",
"/sbin",
]
)
# Don't protect entire home directory to allow cleaning cache/logs
# protected.add(os.path.expanduser("~"))
else: # Linux
protected.update(
[
"/usr",
"/bin",
"/sbin",
"/lib",
"/lib64",
"/etc",
"/boot",
"/sys",
"/proc",
"/dev",
]
)
# Don't protect entire home directory to allow cleaning cache/logs
# protected.add(os.path.expanduser("~"))
return protected
def _is_safe_to_delete(self, path: Path) -> bool:
"""Check if a path is safe to delete"""
try:
resolved = path.expanduser().resolve()
except (OSError, RuntimeError, ValueError):
return False
if self._is_protected_root(resolved):
return False
# Path-aware comparison keeps sibling names such as /usr-local distinct.
for protected in self.protected_paths:
try:
protected_path = Path(protected).expanduser().resolve()
except (OSError, RuntimeError, ValueError):
continue
if resolved == protected_path or protected_path in resolved.parents:
return False
# Check file extension
if resolved.suffix.lower() in self.protected_extensions:
return False
return True
@staticmethod
def _is_filesystem_root(path: Path) -> bool:
"""Return whether path is a POSIX, drive, or UNC filesystem root."""
return bool(path.anchor) and path == Path(path.anchor)
def _is_protected_root(self, path: Path) -> bool:
"""Protect filesystem roots and the current home/profile root."""
if self._is_filesystem_root(path):
return True
try:
home = Path(os.path.expanduser("~")).resolve()
except (OSError, RuntimeError, ValueError):
return True
return path == home
@staticmethod
def _is_reparse_point(metadata: os.stat_result) -> bool:
"""Return whether metadata describes a Windows reparse point."""
attributes = getattr(metadata, "st_file_attributes", 0)
reparse_flag = getattr(stat, "FILE_ATTRIBUTE_REPARSE_POINT", 0)
return bool(attributes & reparse_flag)
def _item_size(self, path: Path, metadata: Optional[os.stat_result] = None) -> int:
"""Measure recursive bytes without following links or reparse points."""
if metadata is None:
metadata = path.lstat()
if (
stat.S_ISLNK(metadata.st_mode)
or self._is_reparse_point(metadata)
or not stat.S_ISDIR(metadata.st_mode)
):
return metadata.st_size
total = 0
pending = [path]
while pending:
with os.scandir(str(pending.pop())) as entries:
for entry in entries:
metadata = entry.stat(follow_symlinks=False)
if stat.S_ISDIR(metadata.st_mode) and not self._is_reparse_point(metadata):
pending.append(Path(entry.path))
else:
total += metadata.st_size
return total
def _rmtree_legacy_windows(self, path: Path) -> None:
"""Remove a directory tree without following Windows reparse points."""
with os.scandir(str(path)) as entries:
for entry in entries:
entry_path = Path(entry.path)
metadata = entry.stat(follow_symlinks=False)
if stat.S_ISLNK(metadata.st_mode):
entry_path.unlink()
elif self._is_reparse_point(metadata):
if stat.S_ISDIR(metadata.st_mode):
entry_path.rmdir()
else:
entry_path.unlink()
elif stat.S_ISDIR(metadata.st_mode):
self._rmtree_legacy_windows(entry_path)
else:
entry_path.unlink()
path.rmdir()
def validate_custom_path(
self,
path: str,
force: bool = False,
allow_unsafe: bool = False,
confirm_path: Optional[str] = None,
) -> Tuple[str, Tuple[int, int]]:
"""Resolve and validate a user-supplied cleanup directory."""
requested_path = Path(path).expanduser()
try:
initial_metadata = requested_path.stat()
except OSError as error:
raise UnsafePathError(f"Cannot inspect custom path {requested_path}: {error}")
if not stat.S_ISDIR(initial_metadata.st_mode):
raise UnsafePathError(f"Custom path must be a directory: {requested_path}")
identity = (initial_metadata.st_dev, initial_metadata.st_ino)
try:
target = requested_path.resolve()
resolved_metadata = target.stat()
except (OSError, RuntimeError, ValueError) as error:
raise UnsafePathError(f"Cannot resolve custom path {path!r}: {error}")
if (resolved_metadata.st_dev, resolved_metadata.st_ino) != identity:
raise UnsafePathError(f"Custom path changed during validation: {requested_path}")
if self._is_protected_root(target):
raise UnsafePathError(f"Filesystem and home/profile roots are protected: {target}")
if not self._is_safe_to_delete(target):
raise UnsafePathError(f"Protected path: {target}")
leaf_name = target.name.casefold().lstrip(".")
project_markers = sorted(marker for marker in PROJECT_MARKERS if (target / marker).exists())
if not allow_unsafe and (leaf_name not in JUNK_DIRECTORY_NAMES or project_markers):
detail = (
f"project markers found ({', '.join(project_markers)})"
if project_markers
else f"directory name {target.name!r} is outside the junk-name allowlist"
)
raise UnsafePathError(f"Custom path requires --allow-unsafe-path: {target} ({detail})")
if force:
if not confirm_path:
raise UnsafePathError(f"--path with --force requires --confirm-path {target}")
confirmation = Path(confirm_path).expanduser()
if not confirmation.is_absolute():
raise UnsafePathError(f"--confirm-path must be absolute: {target}")
try:
confirmation = confirmation.resolve()
except (OSError, RuntimeError, ValueError) as error:
raise UnsafePathError(f"Cannot resolve --confirm-path: {error}")
if confirmation != target:
raise UnsafePathError(f"--confirm-path must match the cleanup target: {target}")
try:
final_metadata = target.stat()
except OSError as error:
raise UnsafePathError(f"Cannot revalidate custom path {target}: {error}")
if (final_metadata.st_dev, final_metadata.st_ino) != identity:
raise UnsafePathError(f"Custom path changed during validation: {target}")
return str(target), identity
def _deduplicate_paths(self, paths: List[str]) -> List[str]:
"""Deduplicate list of paths by resolving to real paths."""
seen = set()
unique_paths = []
for path in paths:
if path and os.path.exists(path):
# Resolve to real path to handle symlinks and duplicates
real_path = os.path.realpath(path)
if real_path not in seen:
seen.add(real_path)
unique_paths.append(real_path)
return unique_paths
def get_cleanable_locations(self) -> Dict[str, List[str]]:
"""Get platform-specific locations that can be cleaned"""
locations = {"temp": [], "cache": [], "logs": [], "recycle": [], "downloads_old": []}
if self.system == "windows":
# Temp directories
temp_dirs = [
os.environ.get("TEMP", ""),
os.environ.get("TMP", ""),
os.path.join(os.environ.get("LOCALAPPDATA", ""), "Temp"),
]
locations["temp"].extend(self._deduplicate_paths(temp_dirs))
# Cache directories
cache_dirs = [
os.path.join(
os.environ.get("LOCALAPPDATA", ""), "Microsoft", "Windows", "INetCache"
),
os.path.join(
os.environ.get("LOCALAPPDATA", ""),
"Google",
"Chrome",
"User Data",
"Default",
"Cache",
),
os.path.join(os.environ.get("APPDATA", ""), "Mozilla", "Firefox", "Profiles"),
os.path.join(
os.environ.get("LOCALAPPDATA", ""),
"Microsoft",
"Edge",
"User Data",
"Default",
"Cache",
),
]
locations["cache"].extend(self._deduplicate_paths(cache_dirs))
# Windows specific
locations["logs"].extend(
[
os.path.join(
os.environ.get("LOCALAPPDATA", ""), "Microsoft", "Windows", "History"
),
os.path.join(
os.environ.get("LOCALAPPDATA", ""), "Microsoft", "Windows", "WebCache"
),
]
)
# Recycle Bin
recycle_path = os.path.join(os.environ.get("SYSTEMDRIVE", "C:"), "$Recycle.Bin")
if os.path.exists(recycle_path):
locations["recycle"].append(recycle_path)
# Prefetch
prefetch = os.path.join(os.environ.get("WINDIR", ""), "Prefetch")
if os.path.exists(prefetch):
locations["temp"].append(prefetch)
# Windows Update cache
update_cache = os.path.join(
os.environ.get("WINDIR", ""), "SoftwareDistribution", "Download"
)
if os.path.exists(update_cache):
locations["temp"].append(update_cache)
elif self.system == "darwin":
# macOS temp and cache
locations["temp"].extend(
[
"/tmp",
"/private/tmp",
]
)
locations["cache"].extend(
[
os.path.expanduser("~/Library/Caches"),
]
)
# User logs
locations["logs"].append(os.path.expanduser("~/Library/Logs"))
# iOS device backups
backup_path = os.path.expanduser("~/Library/Application Support/MobileSync/Backup")
if os.path.exists(backup_path):
locations["cache"].append(backup_path)
else: # Linux
# System temp and cache
locations["temp"].extend(
[
"/tmp",
"/var/tmp",
]
)
locations["cache"].extend(
[
"/var/cache",
]
)
# User cache
user_cache = os.path.expanduser("~/.cache")
if os.path.exists(user_cache):
locations["cache"].append(user_cache)
# Deduplicate all location lists
for key in locations:
locations[key] = self._deduplicate_paths(locations[key])
return locations
def clean_directory(
self,
path: str,
older_than_days: int = 0,
max_size_mb: int = None,
pattern: str = "*",
show_progress: bool = True,
expected_identity: Optional[Tuple[int, int]] = None,
) -> Dict:
"""
Clean a directory with safety checks and optional progress bar.
Args:
path: Directory path to clean
older_than_days: Only delete files older than this many days
max_size_mb: Only delete files smaller than this size (MB)
pattern: Glob pattern to match files
show_progress: Show progress bar for this operation
expected_identity: Validated device and inode for a custom cleanup root
Returns:
Dictionary with cleaning results
"""
result = {"path": path, "files_deleted": 0, "space_freed_mb": 0, "errors": []}
requested_path = Path(path).expanduser()
if expected_identity is not None:
try:
current_metadata = requested_path.stat()
except OSError as error:
message = f"Cannot revalidate cleanup root {requested_path}: {error}"
result["errors"].append(message)
self.errors.append(message)
return result
if (current_metadata.st_dev, current_metadata.st_ino) != expected_identity:
message = f"Cleanup root changed after validation: {requested_path}"
result["errors"].append(message)
self.errors.append(message)
return result
try:
dir_path = requested_path.resolve()
except (OSError, RuntimeError, ValueError) as error:
result["errors"].append(str(error))
self.errors.append(f"{path}: {error}")
return result
if not dir_path.exists():
return result
if not self._is_safe_to_delete(dir_path):
error = f"Refusing protected cleanup root: {dir_path}"
result["errors"].append(error)
self.errors.append(error)
return result
cutoff_date = datetime.now() - timedelta(days=older_than_days)
try:
# Collect all items first for progress bar
items = list(dir_path.glob(pattern))
if self.show_progress and show_progress and len(items) > 0:
progress = ProgressBar(len(items), prefix=f"Cleaning {Path(path).name}")
else:
progress = None
for item in items:
if not item.exists():
continue
try:
# Safety check
if not self._is_safe_to_delete(item):
continue
# Age check
if older_than_days > 0:
mtime = datetime.fromtimestamp(item.stat().st_mtime)
if mtime > cutoff_date:
continue
# One snapshot drives preview, filtering, and deletion type selection.
metadata = item.lstat()
size = self._item_size(item, metadata)
# Size check
if max_size_mb is not None:
size_mb = size / (1024 * 1024)
if size_mb > max_size_mb:
continue
# Delete (or simulate)
if self.dry_run:
result["files_deleted"] += 1
result["space_freed_mb"] += size / (1024 * 1024)
else:
if stat.S_ISLNK(metadata.st_mode):
item.unlink()
elif self._is_reparse_point(metadata):
if stat.S_ISDIR(metadata.st_mode):
item.rmdir()
else:
item.unlink()
elif stat.S_ISDIR(metadata.st_mode):
if self.system == "windows" and sys.version_info < (3, 8):
self._rmtree_legacy_windows(item)
else:
shutil.rmtree(item)
else:
item.unlink()
result["files_deleted"] += 1
result["space_freed_mb"] += size / (1024 * 1024)
# Update progress (safely get item name)
if progress:
try:
item_name = item.name
except (AttributeError, OSError, RuntimeError):
item_name = str(item)
progress.update(1, item_name)
except (PermissionError, OSError) as e:
result["errors"].append(str(e))
self.errors.append(f"{item}: {e}")
except (AttributeError, RuntimeError) as e:
# Handle unexpected errors from accessing item attributes
result["errors"].append(str(e))
self.errors.append(f"{item}: {e}")
if progress:
progress.close()
except (PermissionError, OSError) as e:
result["errors"].append(str(e))
self.errors.append(f"{dir_path}: {e}")
result["space_freed_mb"] = round(result["space_freed_mb"], 2)
return result
def clean_temp_files(self, show_progress: bool = True) -> Dict:
"""Clean temporary files with progress bar"""
locations = self.get_cleanable_locations()
results = {"category": "temp_files", "locations": []}
temp_dirs = locations.get("temp", [])
if self.show_progress and show_progress and len(temp_dirs) > 0:
progress = ProgressBar(len(temp_dirs), prefix="Cleaning temp")
else:
progress = None
for temp_dir in temp_dirs:
result = self.clean_directory(temp_dir, older_than_days=0, show_progress=False)
results["locations"].append(result)
if progress:
progress.update(1, Path(temp_dir).name)
if progress:
progress.close()
return results
def clean_cache_files(self, show_progress: bool = True) -> Dict:
"""Clean cache files with progress bar"""
locations = self.get_cleanable_locations()
results = {"category": "cache", "locations": []}
cache_dirs = locations.get("cache", [])
if self.show_progress and show_progress and len(cache_dirs) > 0:
progress = ProgressBar(len(cache_dirs), prefix="Cleaning cache")
else:
progress = None
for cache_dir in cache_dirs:
result = self.clean_directory(cache_dir, older_than_days=30, show_progress=False)
results["locations"].append(result)
if progress:
progress.update(1, Path(cache_dir).name)
if progress:
progress.close()
return results
def clean_log_files(self, show_progress: bool = True) -> Dict:
"""Clean log files with progress bar"""
locations = self.get_cleanable_locations()
results = {"category": "logs", "locations": []}
log_dirs = locations.get("logs", [])
if self.show_progress and show_progress and len(log_dirs) > 0:
progress = ProgressBar(len(log_dirs), prefix="Cleaning logs")
else:
progress = None
for log_dir in log_dirs:
result = self.clean_directory(
log_dir, older_than_days=30, pattern="*.log", show_progress=False
)
results["locations"].append(result)
if progress:
progress.update(1, Path(log_dir).name)
if progress:
progress.close()
return results
def clean_recycle_bin(self, show_progress: bool = True) -> Dict:
"""Clean recycle bin/trash with progress bar"""
locations = self.get_cleanable_locations()
results = {"category": "recycle_bin", "locations": []}
recycle_dirs = locations.get("recycle", [])
if self.show_progress and show_progress and len(recycle_dirs) > 0:
progress = ProgressBar(len(recycle_dirs), prefix="Emptying recycle")
else:
progress = None
for recycle_dir in recycle_dirs:
result = self.clean_directory(recycle_dir, older_than_days=30, show_progress=False)
results["locations"].append(result)
if progress:
progress.update(1, Path(recycle_dir).name)
if progress:
progress.close()
return results
def clean_old_downloads(self, days: int = 90, show_progress: bool = True) -> Dict:
"""Clean old download files with progress bar"""
downloads_path = os.path.expanduser("~/Downloads")
results = {"category": "old_downloads", "locations": []}
if os.path.exists(downloads_path):
result = self.clean_directory(
downloads_path, older_than_days=days, show_progress=show_progress
)
results["locations"].append(result)
return results
def clean_all(self, show_progress: bool = True) -> Dict:
"""Run all cleaning operations with progress bars"""
results = {
"timestamp": datetime.now().isoformat(),
"platform": self.platform,
"dry_run": self.dry_run,
"categories": [],
}
# Clean temp files
temp_result = self.clean_temp_files(show_progress=show_progress)
results["categories"].append(temp_result)
# Clean cache
cache_result = self.clean_cache_files(show_progress=show_progress)
results["categories"].append(cache_result)
# Clean logs
log_result = self.clean_log_files(show_progress=show_progress)
results["categories"].append(log_result)
# Clean recycle bin
recycle_result = self.clean_recycle_bin(show_progress=show_progress)
results["categories"].append(recycle_result)
# Calculate totals
total_files = 0
total_space_mb = 0
for category in results["categories"]:
for location in category["locations"]:
total_files += location["files_deleted"]
total_space_mb += location["space_freed_mb"]
results["summary"] = {
"total_files_deleted": total_files,
"total_space_freed_mb": round(total_space_mb, 2),
"total_space_freed_gb": round(total_space_mb / 1024, 2),
"total_errors": len(self.errors),
}
return results
def print_report(results: Dict):
"""Print formatted cleaning report"""
mode = "DRY RUN" if results["dry_run"] else "CLEAN"
print("\n" + "=" * 60)
print(f"DISK CLEANING REPORT ({mode}) - {results['timestamp']}")
print("=" * 60)
for category in results["categories"]:
print(f"\n[x] {category['category'].upper().replace('_', ' ')}:")
# Safely handle categories with no locations
if not category.get("locations"):
print(" [i] No locations found for this category")
continue
for location in category["locations"]:
if location.get("files_deleted", 0) > 0:
space_mb = location.get("space_freed_mb", 0)
space_str = f"{space_mb:.2f} MB" if space_mb < 1024 else f"{space_mb/1024:.2f} GB"
print(f" [OK] {location.get('path', 'Unknown')}")
print(f" Files: {location.get('files_deleted', 0)}, Space: {space_str}")
elif location.get("errors"):
print(f" [!] {location.get('path', 'Unknown')}: {len(location['errors'])} errors")
summary = results["summary"]
print("\n[i] SUMMARY:")
print(f" Total files: {summary['total_files_deleted']}")
print(f" Space freed: {summary['total_space_freed_gb']:.2f} GB")
if summary["total_errors"] > 0:
print(f" [!] Errors: {summary['total_errors']}")
if results["dry_run"]:
print("\n[i] This was a DRY RUN. No files were actually deleted.")
print(" Run without --dry-run to perform actual cleaning.")
print("=" * 60)
def main():
import argparse
parser = argparse.ArgumentParser(
description="Clean disk junk files",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
Examples:
# Preview cleaning (safe mode)
python scripts/clean_disk.py --dry-run
# Actually clean
python scripts/clean_disk.py --force
# Clean specific categories
python scripts/clean_disk.py --temp --cache --dry-run
# Clean old downloads (>90 days)
python scripts/clean_disk.py --downloads 90 --force
# Clean custom path (e.g., D:\\Temp on secondary drive)
python scripts/clean_disk.py --path "D:/Temp" --dry-run
# Clean system paths + custom path
python scripts/clean_disk.py --temp --path "D:/Downloads" --force \\
--confirm-path "D:/Downloads"
""",
)
parser.add_argument(
"--dry-run",
action="store_true",
default=True,
help="Simulate cleaning without deleting (default: True)",
)
parser.add_argument(
"--force", action="store_true", help="Actually delete files (disables dry-run)"
)
parser.add_argument("--temp", action="store_true", help="Clean only temp files")
parser.add_argument("--cache", action="store_true", help="Clean only cache")
parser.add_argument("--logs", action="store_true", help="Clean only logs")
parser.add_argument("--recycle", action="store_true", help="Clean only recycle bin")
parser.add_argument(
"--downloads", type=int, metavar="DAYS", help="Clean downloads older than N days"
)
parser.add_argument(
"--path",
"-p",
help="Clean a custom directory recursively. Junk directory names are accepted by default.",
)
parser.add_argument(
"--allow-unsafe-path",
action="store_true",
help="Allow a custom path whose target name is outside the junk allowlist",
)
parser.add_argument(
"--confirm-path",
metavar="ABSOLUTE_PATH",
help="Exact resolved path required with --path --force",
)
parser.add_argument("--json", action="store_true", help="Output as JSON")
parser.add_argument("--output", "-o", help="Save report to file")
parser.add_argument(
"--no-progress", action="store_true", help="Disable progress bars (useful for scripting)"
)
args = parser.parse_args()
dry_run = args.dry_run and not args.force
show_progress = not args.no_progress and not args.json
cleaner = DiskCleaner(dry_run=dry_run, show_progress=show_progress)
# Run specific or all cleaning
if args.path:
requested_path = Path(args.path).expanduser()
if not requested_path.exists():
print(f"[X] Error: Path does not exist: {args.path}", file=sys.stderr)
sys.exit(1)
try:
custom_path, custom_identity = cleaner.validate_custom_path(
str(requested_path),
force=args.force,
allow_unsafe=args.allow_unsafe_path,
confirm_path=args.confirm_path,
)
except UnsafePathError as error:
print(f"[X] Refusing custom path: {error}", file=sys.stderr)
sys.exit(2)
result = cleaner.clean_directory(
custom_path,
show_progress=show_progress,
expected_identity=custom_identity,
)
results = {
"timestamp": datetime.now().isoformat(),
"dry_run": dry_run,
"categories": [
{"category": "custom_path", "locations": [result]},
],
}
# If also cleaning system categories, add them
if args.temp:
results["categories"].append(cleaner.clean_temp_files())
if args.cache:
results["categories"].append(cleaner.clean_cache_files())
if args.logs:
results["categories"].append(cleaner.clean_log_files())
elif args.temp:
results = {
"timestamp": datetime.now().isoformat(),
"dry_run": dry_run,
"categories": [cleaner.clean_temp_files()],
}
elif args.cache:
results = {
"timestamp": datetime.now().isoformat(),
"dry_run": dry_run,
"categories": [cleaner.clean_cache_files()],
}
elif args.logs:
results = {
"timestamp": datetime.now().isoformat(),
"dry_run": dry_run,
"categories": [cleaner.clean_log_files()],
}
elif args.recycle:
results = {
"timestamp": datetime.now().isoformat(),
"dry_run": dry_run,
"categories": [cleaner.clean_recycle_bin()],
}
elif args.downloads:
results = {
"timestamp": datetime.now().isoformat(),
"dry_run": dry_run,
"categories": [cleaner.clean_old_downloads(args.downloads)],
}
else:
results = cleaner.clean_all()
# Calculate summary if not already present
if "summary" not in results:
total_files = 0
total_space = 0
total_errors = 0
for category in results["categories"]:
# Safely sum across all locations (categories may have no locations)
if category.get("locations"):
for location in category["locations"]:
total_files += location.get("files_deleted", 0)
total_space += location.get("space_freed_mb", 0)
total_errors += len(location.get("errors", []))
results["summary"] = {
"total_files_deleted": total_files,
"total_space_freed_mb": round(total_space, 2),
"total_space_freed_gb": round(total_space / 1024, 2),
"total_errors": total_errors,
}
if args.json:
print(json.dumps(results, indent=2))
else:
print_report(results)
if args.output:
with open(args.output, "w") as f:
json.dump(results, f, indent=2)
print(f"\n[OK] Report saved to {args.output}")
if results["summary"]["total_errors"] > 0:
sys.exit(1)
if __name__ == "__main__":
main()
scripts/find_duplicates.py
#!/usr/bin/env python3
"""
Duplicate File Finder - Find and report duplicate files
This script finds duplicate files using SHA-256 hash comparison.
It supports multiple strategies:
- adaptive: Automatically choose between fast and accurate (default)
- fast: Size + mtime pre-filtering for large directories
- accurate: SHA-256 hash comparison for smaller directories
Features:
- Progress bars for large scans
- ASCII-safe output for cross-platform compatibility
- Detailed statistics and reclaimable space calculation
"""
import argparse
import json
import os
import platform
import sys
from datetime import datetime
from pathlib import Path
from typing import Dict, List
# Add parent directory to path for imports
script_dir = Path(__file__).parent.parent
if str(script_dir) not in sys.path:
sys.path.insert(0, str(script_dir))
try:
from diskcleaner.core.duplicate_finder import DuplicateFinder, DuplicateGroup
from diskcleaner.core.progress import ProgressBar
from diskcleaner.core.scanner import DirectoryScanner
PROGRESS_AVAILABLE = True
except ImportError:
print("Warning: diskcleaner modules not available", file=sys.stderr)
PROGRESS_AVAILABLE = False
def format_size(bytes_size: int) -> str:
"""
Format byte size to human-readable string.
Args:
bytes_size: Size in bytes
Returns:
Formatted string (e.g., "1.5 GB", "500 MB")
"""
for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
if bytes_size < 1024.0:
return f"{bytes_size:.2f} {unit}"
bytes_size /= 1024.0
return f"{bytes_size:.2f} PB"
def print_duplicates(duplicates: List[DuplicateGroup], show_all: bool = False):
"""
Print duplicate file groups to console.
Args:
duplicates: List of DuplicateGroup objects
show_all: Show all files or just summary
"""
if not duplicates:
print("\nNo duplicate files found!")
return
print(f"\nFound {len(duplicates)} groups of duplicate files:")
print("=" * 80)
for i, group in enumerate(duplicates, 1):
print(f"\nGroup {i}: {group.count} files x {format_size(group.size)}")
print(f" Reclaimable: {format_size(group.reclaimable_space)}")
print(f" Files:")
for j, file_info in enumerate(group.files, 1):
print(f" {j}. {file_info.path}")
# Only show first 10 groups unless --all is specified
if i >= 10 and not show_all:
remaining = len(duplicates) - 10
print(f"\n... and {remaining} more groups (use --all to see all)")
break
def print_statistics(duplicates: List[DuplicateGroup]):
"""
Print statistics about duplicate files.
Args:
duplicates: List of DuplicateGroup objects
"""
if not duplicates:
print("\nNo duplicate files found!")
return
# Calculate statistics
group_count = len(duplicates)
total_files = sum(g.count for g in duplicates)
total_size = sum(g.size * g.count for g in duplicates)
total_reclaimable = sum(g.reclaimable_space for g in duplicates)
# Find largest group
largest_group = max(duplicates, key=lambda g: g.reclaimable_space)
print("\n" + "=" * 80)
print("DUPLICATE FILE STATISTICS")
print("=" * 80)
print(f"Total duplicate groups: {group_count}")
print(f"Total duplicate files: {total_files}")
print(f"Total size of duplicates: {format_size(total_size)}")
print(f"Total reclaimable space: {format_size(total_reclaimable)}")
print(f"\nLargest duplicate group:")
print(f" Files: {largest_group.count}")
print(f" Size per file: {format_size(largest_group.size)}")
print(f" Reclaimable: {format_size(largest_group.reclaimable_space)}")
print("=" * 80)
def find_duplicates(
path: str,
strategy: str = "adaptive",
show_progress: bool = True,
max_files: int = None,
max_seconds: int = None,
) -> tuple[List[DuplicateGroup], Dict]:
"""
Find duplicate files in the specified path.
Args:
path: Path to scan for duplicates
strategy: Detection strategy ('adaptive', 'fast', 'accurate')
show_progress: Show progress bar
max_files: Maximum number of files to scan
max_seconds: Maximum scan time in seconds
Returns:
Tuple of (duplicates list, statistics dict)
"""
scan_path = Path(path)
if not scan_path.exists():
raise ValueError(f"Path does not exist: {path}")
if not scan_path.is_dir():
raise ValueError(f"Path is not a directory: {path}")
print(f"Scanning {scan_path} for duplicates...")
# Collect all files using DirectoryScanner if available
all_files = []
if PROGRESS_AVAILABLE:
try:
scanner = DirectoryScanner(
str(scan_path),
max_files=max_files or 1000000,
max_seconds=max_seconds or 300,
cache_enabled=False,
)
if show_progress and sys.stdout.isatty():
progress = ProgressBar(None, prefix="Scanning files")
file_count = 0
for file_info in scanner.scan_generator():
if not file_info.is_dir:
all_files.append(file_info)
file_count += 1
if file_count % 100 == 0:
progress.update(file_count, f"Found {file_count} files")
progress.close()
else:
for file_info in scanner.scan_generator():
if not file_info.is_dir:
all_files.append(file_info)
if scanner.stopped_early:
print(f"\nWarning: Scan stopped early - {scanner.stop_reason}")
except Exception as e:
print(f"Scanner error: {e}", file=sys.stderr)
print("Falling back to basic scan...", file=sys.stderr)
# Fallback to basic scan
all_files = _basic_scan(scan_path)
else:
# Basic scan without DirectoryScanner
all_files = _basic_scan(scan_path)
if not all_files:
print("No files found in directory")
return [], {}
print(f"Analyzing {len(all_files)} files for duplicates...")
# Find duplicates
finder = DuplicateFinder(strategy=strategy)
duplicates = finder.find_duplicates(all_files)
# Get statistics
stats = finder.get_duplicate_stats(duplicates)
return duplicates, stats
def _basic_scan(scan_path: Path) -> List:
"""
Basic file scan without DirectoryScanner.
Args:
scan_path: Path to scan
Returns:
List of file info objects
"""
# Import FileInfo for creating objects
from diskcleaner.core.scanner import FileInfo
all_files = []
try:
for root, dirs, files in os.walk(scan_path):
for filename in files:
try:
filepath = os.path.join(root, filename)
stat = os.stat(filepath)
# Create FileInfo object
file_info = FileInfo(
path=filepath,
name=filename,
size=stat.st_size,
is_dir=False,
mtime=stat.st_mtime,
)
all_files.append(file_info)
except (OSError, PermissionError):
continue
except (OSError, PermissionError) as e:
print(f"Error scanning directory: {e}", file=sys.stderr)
return all_files
def generate_report(
path: str,
duplicates: List[DuplicateGroup],
stats: Dict,
) -> Dict:
"""
Generate a comprehensive report.
Args:
path: Path that was scanned
duplicates: List of duplicate groups
stats: Statistics dictionary
Returns:
Report dictionary
"""
report = {
"timestamp": datetime.now().isoformat(),
"platform": platform.system(),
"path": path,
"statistics": stats,
"duplicates": [],
}
# Add duplicate group details
for group in duplicates:
group_data = {
"count": group.count,
"size": group.size,
"size_human": format_size(group.size),
"reclaimable_space": group.reclaimable_space,
"reclaimable_human": format_size(group.reclaimable_space),
"hash": group.hash_value,
"files": [f.path for f in group.files],
}
report["duplicates"].append(group_data)
return report
def main():
"""Main entry point"""
# Fix Windows console encoding
if sys.platform == "win32":
import codecs
sys.stdout = codecs.getwriter("utf-8")(sys.stdout.buffer, "strict")
sys.stderr = codecs.getwriter("utf-8")(sys.stderr.buffer, "strict")
parser = argparse.ArgumentParser(
description="Find duplicate files using hash comparison",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
Examples:
# Find duplicates in current directory
python scripts/find_duplicates.py
# Find duplicates in specific path
python scripts/find_duplicates.py --path "/path/to/directory"
# Use fast strategy for large directories
python scripts/find_duplicates.py --strategy fast
# Show all duplicate groups (not just first 10)
python scripts/find_duplicates.py --all
# Output as JSON
python scripts/find_duplicates.py --json --output duplicates.json
# With scan limits for large directories
python scripts/find_duplicates.py --file-limit 500000 --time-limit 180
""",
)
parser.add_argument(
"--path",
"-p",
default=".",
help="Path to scan for duplicates (default: current directory)",
)
parser.add_argument(
"--strategy",
"-s",
choices=["adaptive", "fast", "accurate"],
default="adaptive",
help="Duplicate detection strategy (default: adaptive)",
)
parser.add_argument(
"--all",
action="store_true",
help="Show all duplicate groups (not just first 10)",
)
parser.add_argument(
"--json", action="store_true", help="Output as JSON instead of human-readable"
)
parser.add_argument(
"--output", "-o", help="Save report to file (JSON format)"
)
parser.add_argument(
"--file-limit",
type=int,
default=None,
help="Maximum number of files to scan (default: 1000000)",
)
parser.add_argument(
"--time-limit",
type=int,
default=None,
help="Maximum scan time in seconds (default: 300)",
)
parser.add_argument(
"--no-progress",
action="store_true",
help="Disable progress bars (useful for scripting)",
)
args = parser.parse_args()
try:
# Find duplicates
show_progress = not args.no_progress and not args.json
duplicates, stats = find_duplicates(
path=args.path,
strategy=args.strategy,
show_progress=show_progress,
max_files=args.file_limit,
max_seconds=args.time_limit,
)
# Output results
if args.json:
# Generate and output JSON report
report = generate_report(args.path, duplicates, stats)
print(json.dumps(report, indent=2))
else:
# Print human-readable output
print_statistics(duplicates)
print_duplicates(duplicates, show_all=args.all)
# Save to file if requested
if args.output:
report = generate_report(args.path, duplicates, stats)
with open(args.output, "w", encoding="utf-8") as f:
json.dump(report, f, indent=2)
print(f"\nReport saved to {args.output}")
# Exit code based on whether duplicates were found
sys.exit(0 if len(duplicates) == 0 else 1)
except Exception as e:
print(f"Error: {e}", file=sys.stderr)
sys.exit(2)
if __name__ == "__main__":
main()
scripts/interactive_wizard.py
#!/usr/bin/env python3
"""
Interactive Wizard for Disk Cleanup
A comprehensive interactive wizard that guides users through the disk cleanup process.
Features:
- Welcome screen with safety information
- Scan mode selection (Quick/Standard/Deep/Progressive/Custom)
- Categorized display with risk levels
- Multi-level confirmation process
- ASCII-safe output for terminals
This script integrates with existing diskcleaner components:
- InteractiveCleanupUI for display and selection
- ProgressBar for progress indication
- DirectoryScanner for file scanning
"""
import sys
import time
from pathlib import Path
from typing import Dict, List, Optional, Set, Tuple
# Add parent directory to path for imports
SCRIPT_DIR = Path(__file__).parent.parent
sys.path.insert(0, str(SCRIPT_DIR))
from diskcleaner.config import Config
from diskcleaner.core.interactive import InteractiveCleanupUI
from diskcleaner.core.progress import ProgressBar, IndeterminateProgress
from diskcleaner.core.scanner import DirectoryScanner
from diskcleaner.core.smart_cleanup import SmartCleanupEngine, CleanupReport
class InteractiveWizard:
"""
Interactive wizard for disk cleanup operations.
Provides a user-friendly, step-by-step interface for cleaning disk space.
"""
def __init__(self, target_path: str = "."):
"""
Initialize the interactive wizard.
Args:
target_path: Path to analyze (default: current directory)
"""
self.target_path = Path(target_path).expanduser().resolve()
self.config = Config.load()
self.engine = SmartCleanupEngine(str(self.target_path), self.config)
self.ui = InteractiveCleanupUI(self.engine)
self.scan_mode = None
self.selected_files: Set[str] = set()
def run(self) -> bool:
"""
Run the complete wizard workflow.
Returns:
True if cleanup was performed, False otherwise.
"""
try:
# Step 1: Welcome screen
if not self._show_welcome():
return False
# Step 2: Select scan mode
self.scan_mode = self._select_scan_mode()
if not self.scan_mode:
return False
# Step 3: Perform scan
report = self._perform_scan()
if not report:
print("\n扫描未返回结果")
return False
# Step 4: Display and select files
self._display_report_and_select(report)
# Step 5: Multi-level confirmation
if not self.selected_files:
print("\n未选择任何文件")
return False
if not self._confirm_cleanup():
return False
# Step 6: Execute cleanup
return self._execute_cleanup()
except KeyboardInterrupt:
print("\n\n操作已取消")
return False
except Exception as e:
print(f"\n错误: {e}")
import traceback
traceback.print_exc()
return False
def _show_welcome(self) -> bool:
"""
Display welcome screen with safety information.
Returns:
True if user wants to continue, False otherwise.
"""
print("\n" + "=" * 60)
print(" 磁盘清理向导")
print("=" * 60)
print()
print("欢迎使用磁盘清理工具！")
print()
print("功能特性:")
print(" - 智能分类：按类型、风险、时间三维分析")
print(" - 安全第一：多重确认，误删保护")
print(" - 重复文件：快速识别并清理重复内容")
print(" - 增量扫描：缓存机制，提升性能")
print()
print("安全承诺:")
print(" 1. 不会删除任何文件，除非您明确确认")
print(" 2. 所有操作都需要您输入 'YES' 确认")
print(" 3. 危险操作需要额外输入 'I UNDERSTAND'")
print(" 4. 所有删除操作都会记录日志")
print(" 5. 可选备份功能，保护重要文件")
print()
print("=" * 60)
choice = input("\n是否继续？ [Y/n]: ").strip().lower()
return choice in ("", "y", "yes")
def _select_scan_mode(self) -> Optional[str]:
"""
Display scan mode selection menu.
Returns:
Selected scan mode, or None if cancelled.
"""
while True:
print("\n" + "=" * 60)
print(" 选择扫描模式")
print("=" * 60)
print()
print("1. 快速扫描 (1秒)")
print(" - 扫描常见临时文件位置")
print(" - 适合日常清理")
print()
print("2. 标准扫描 (2分钟)")
print(" - 全面扫描当前目录")
print(" - 包含子目录")
print(" - 推荐模式")
print()
print("3. 深度扫描 (无限制)")
print(" - 扫描所有文件")
print(" - 可能需要较长时间")
print(" - 适合彻底清理")
print()
print("4. 渐进式扫描")
print(" - 使用缓存增量扫描")
print(" - 后续扫描更快")
print(" - 适合定期清理")
print()
print("5. 自定义扫描")
print(" - 自定义扫描参数")
print(" - 高级选项")
print()
print("0. 退出")
print()
print("=" * 60)
choice = input("\n请选择 (0-5): ").strip()
if choice == "0":
return None
elif choice in ("1", "2", "3", "4", "5"):
return self._get_scan_mode_config(choice)
else:
print("无效选择，请重试")
def _get_scan_mode_config(self, mode: str) -> str:
"""
Get scan mode configuration.
Args:
mode: Mode number (1-5)
Returns:
Scan mode identifier.
"""
modes = {
"1": "quick",
"2": "standard",
"3": "deep",
"4": "progressive",
"5": "custom",
}
return modes.get(mode, "standard")
def _perform_scan(self) -> Optional[CleanupReport]:
"""
Perform the scan based on selected mode.
Returns:
CleanupReport if successful, None otherwise.
"""
print(f"\n正在扫描: {self.target_path}")
print(f"扫描模式: {self._get_scan_mode_name(self.scan_mode)}")
print()
# Configure scanner based on mode
if self.scan_mode == "quick":
# Quick scan: limit files and time
scanner = DirectoryScanner(
str(self.target_path),
config=self.config,
max_files=10000,
max_seconds=1,
cache_enabled=False,
)
elif self.scan_mode == "standard":
# Standard scan: balanced limits
scanner = DirectoryScanner(
str(self.target_path),
config=self.config,
max_files=100000,
max_seconds=120,
cache_enabled=True,
)
elif self.scan_mode == "deep":
# Deep scan: no limits
scanner = DirectoryScanner(
str(self.target_path),
config=self.config,
max_files=None,
max_seconds=None,
cache_enabled=True,
)
elif self.scan_mode == "progressive":
# Progressive scan: use incremental
scanner = DirectoryScanner(
str(self.target_path),
config=self.config,
cache_enabled=True,
)
else: # custom
# Ask user for custom parameters
max_files = self._ask_custom_param("最大文件数 (默认无限制): ", None)
max_seconds = self._ask_custom_param("最大扫描时间/秒 (默认无限制): ", None)
scanner = DirectoryScanner(
str(self.target_path),
config=self.config,
max_files=max_files,
max_seconds=max_seconds,
cache_enabled=True,
)
# Perform scan with progress indication
try:
# Use indeterminate progress for scanning
with IndeterminateProgress("扫描中", enable=True) as progress:
# Monkey-patch the scanner to update progress
original_scan = scanner.scan_generator
def scan_with_progress():
for file_info in original_scan():
progress.tick(f"扫描: {file_info.name[:30]}")
yield file_info
scanner.scan_generator = scan_with_progress
# Analyze with engine
report = self.engine.analyze()
print() # Newline after progress
# Show scan summary
self._show_scan_summary(report, scanner)
return report
except Exception as e:
print(f"\n扫描失败: {e}")
return None
def _ask_custom_param(self, prompt: str, default: Optional[int]) -> Optional[int]:
"""Ask user for custom parameter."""
while True:
response = input(prompt).strip()
if not response:
return default
try:
value = int(response)
if value <= 0:
print("请输入正整数")
continue
return value
except ValueError:
print("请输入有效的数字")
def _get_scan_mode_name(self, mode: str) -> str:
"""Get display name for scan mode."""
names = {
"quick": "快速扫描",
"standard": "标准扫描",
"deep": "深度扫描",
"progressive": "渐进式扫描",
"custom": "自定义扫描",
}
return names.get(mode, "未知模式")
def _show_scan_summary(self, report: CleanupReport, scanner: DirectoryScanner):
"""Display scan summary."""
total_files = sum(len(files) for files in report.by_type.values())
total_size = sum(
sum(f.size for f in files)
for files in report.by_type.values()
)
print("\n" + "=" * 60)
print(" 扫描完成")
print("=" * 60)
print(f"扫描文件数: {total_files:,}")
print(f"总大小: {self._format_size(total_size)}")
if scanner.stopped_early:
print(f"\n注意: 扫描提前停止 ({scanner.stop_reason})")
print("如需完整扫描，请选择 '深度扫描' 模式")
print(f"发现重复文件组: {len(report.duplicates)}")
print("=" * 60)
def _display_report_and_select(self, report: CleanupReport):
"""
Display report and let user select files.
Args:
report: CleanupReport to display.
"""
while True:
# Main menu
choice = self.ui.display_report_menu(report)
if choice is None:
break
# Display selected view and collect selections
if choice == "1": # By type
selected = self.ui.view_by_type(report)
elif choice == "2": # By risk
selected = self.ui.view_by_risk(report)
elif choice == "3": # By age
selected = self.ui.view_by_age(report)
elif choice == "4": # Duplicates
selected_dup = self.ui.view_duplicates(report)
# Convert duplicate selections to file paths
selected = [path for path, _ in selected_dup]
elif choice == "5": # Detailed list
selected = self.ui.view_detailed_list(report)
elif choice == "6": # Summary
self._show_summary_statistics(report)
continue
# Merge selections
if selected:
self.selected_files.update(selected)
print(f"\n当前已选择 {len(self.selected_files)} 个文件")
def _show_summary_statistics(self, report: CleanupReport):
"""Display summary statistics."""
print("\n" + "=" * 60)
print(" 统计摘要")
print("=" * 60)
# Count by risk level
risk_counts = {}
for risk, files in report.by_risk.items():
risk_counts[risk] = len(files)
print("\n按风险等级:")
for risk, count in sorted(risk_counts.items(), key=lambda x: -x[1]):
emoji = self._get_risk_emoji(risk)
print(f" {emoji} {risk}: {count} 文件")
# Count by type
print("\n按类型 (前5):")
type_items = sorted(
report.by_type.items(),
key=lambda x: sum(f.size for f in x[1]),
reverse=True
)[:5]
for category, files in type_items:
size = sum(f.size for f in files)
print(f" - {category}: {len(files)} 文件, {self._format_size(size)}")
# Duplicates
if report.duplicates:
dup_space = sum(d.reclaimable_space for d in report.duplicates)
print(f"\n重复文件: {len(report.duplicates)} 组, 可回收 {self._format_size(dup_space)}")
print("=" * 60)
def _get_risk_emoji(self, risk: str) -> str:
"""Get emoji for risk level (for agent reports only)."""
emojis = {
"safe": "OK", # Green
"confirm_needed": "!", # Yellow
"protected": "X", # Red
}
return emojis.get(risk, "?")
def _confirm_cleanup(self) -> bool:
"""
Multi-level confirmation process.
Returns:
True if user confirms, False otherwise.
"""
if not self.selected_files:
return False
# Analyze risk levels
risk_breakdown = self._analyze_selection_risk()
# Show cleanup summary grouped by risk
print("\n" + "=" * 60)
print(" 清理确认")
print("=" * 60)
print("\n即将删除的文件按风险分组:")
# Safe files
if "safe" in risk_breakdown:
files, size = risk_breakdown["safe"]
print(f"\n [OK] 安全级别: {len(files)} 文件, {self._format_size(size)}")
print(" 临时文件、缓存等，可安全删除")
# Warning level
if "confirm_needed" in risk_breakdown:
files, size = risk_breakdown["confirm_needed"]
print(f"\n [!] 警告级别: {len(files)} 文件, {self._format_size(size)}")
print(" 开发工具索引、构建产物等，请确认")
# Dangerous level
if "protected" in risk_breakdown:
files, size = risk_breakdown["protected"]
print(f"\n [X] 危险级别: {len(files)} 文件, {self._format_size(size)}")
print(" 用户文档、重要文件等，需逐个确认")
# Require "I UNDERSTAND" for dangerous files
print("\n 警告: 您选择了危险级别的文件！")
confirm = input(" 输入 'I UNDERSTAND' 继续: ").strip()
if confirm != "I UNDERSTAND":
print("\n操作已取消")
return False
# Total summary
total_size = sum(size for _, size in risk_breakdown.values())
total_files = sum(len(files) for files, _ in risk_breakdown.values())
print("\n" + "-" * 60)
print(f"总计: {total_files} 文件, {self._format_size(total_size)}")
print("=" * 60)
# Final confirmation
print("\n此操作将永久删除选定的文件！")
confirm = input("确认删除？输入 'YES' 继续: ").strip()
return confirm == "YES"
def _analyze_selection_risk(self) -> Dict[str, Tuple[List[Path], int]]:
"""
Analyze risk levels of selected files.
Returns:
Dictionary mapping risk level to (files, total_size).
"""
# Get full report to check risk levels
report = self.engine.analyze()
# Build risk mapping
risk_map = {}
for risk, files in report.by_risk.items():
for file in files:
risk_map[file.path] = risk
# Group selected files by risk
result = {
"safe": ([], 0),
"confirm_needed": ([], 0),
"protected": ([], 0),
}
for file_path in self.selected_files:
path = Path(file_path)
risk = risk_map.get(file_path, "confirm_needed")
if path.exists():
try:
size = path.stat().st_size
result[risk][0].append(path)
result[risk] = (result[risk][0], result[risk][1] + size)
except OSError:
pass
# Remove empty categories
return {k: v for k, v in result.items() if v[0]}
def _execute_cleanup(self) -> bool:
"""
Execute the cleanup operation.
Returns:
True if successful, False otherwise.
"""
print("\n开始清理...")
# Use the UI's cleanup method
success = self.ui.confirm_and_cleanup(
list(self.selected_files),
dry_run=False,
backup=True,
)
if success:
print("\n清理完成！")
print(f" 删除文件: {len(self.selected_files)} 个")
return success
def _format_size(self, size_bytes: int) -> str:
"""Format byte size to human-readable string."""
for unit in ["B", "KB", "MB", "GB", "TB"]:
if size_bytes < 1024.0:
if unit == "B":
return f"{size_bytes:,} {unit}"
return f"{size_bytes:.2f} {unit}"
size_bytes /= 1024.0
return f"{size_bytes:.2f} PB"
def main():
"""Main entry point."""
import argparse
parser = argparse.ArgumentParser(
description="Interactive wizard for disk cleanup"
)
parser.add_argument(
"path",
nargs="?",
default=".",
help="Path to analyze (default: current directory)"
)
args = parser.parse_args()
# Run wizard
wizard = InteractiveWizard(args.path)
success = wizard.run()
sys.exit(0 if success else 1)
if __name__ == "__main__":
main()
scripts/monitor_disk.py
#!/usr/bin/env python3
"""
Disk Monitor - Cross-platform disk usage monitoring tool
Monitors disk usage and alerts when thresholds are exceeded
"""
import json
import os
import platform
import signal
import sys
import time
from datetime import datetime
from pathlib import Path
from typing import Dict, List
# monitor_disk.py does not depend on diskcleaner core modules
# But for consistency, we still include bootstrap module for future expansion
try:
script_dir = Path(__file__).parent.resolve()
if str(script_dir) not in sys.path:
sys.path.insert(0, str(script_dir))
from skill_bootstrap import setup_skill_environment
# Setup skill environment (mainly for encoding handling)
_, _ = setup_skill_environment(require_modules=False)
except Exception as e:
# If bootstrap module fails, use basic encoding handling
if platform.system().lower() == "windows" and sys.stdout.isatty():
try:
import io
if hasattr(sys.stdout, "buffer"):
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace")
if hasattr(sys.stderr, "buffer"):
sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8", errors="replace")
except Exception:
pass # Use system default
class DiskMonitor:
def __init__(self, warning_threshold: int = 80, critical_threshold: int = 90):
self.warning_threshold = warning_threshold
self.critical_threshold = critical_threshold
self.platform = platform.system()
self.running = True
# Setup signal handler for graceful shutdown
signal.signal(signal.SIGINT, self._signal_handler)
signal.signal(signal.SIGTERM, self._signal_handler)
def _signal_handler(self, signum, frame):
"""Handle shutdown signals gracefully"""
print("\n\n[STOP] Shutting down monitor...")
self.running = False
def get_mount_points(self) -> List[str]:
"""Get all mount points/drives"""
mount_points = []
if self.platform == "Windows":
# Get all drive letters
import string
for letter in string.ascii_uppercase:
drive = f"{letter}:\\"
if os.path.exists(drive):
mount_points.append(drive)
elif self.platform == "Darwin": # macOS
# Common macOS mount points
mount_points = ["/"]
# Also check /Volumes for external drives
volumes = Path("/Volumes")
if volumes.exists():
for item in volumes.iterdir():
if item.is_dir() and not item.is_symlink():
mount_points.append(str(item))
else: # Linux
# Read from /proc/mounts or /etc/mtab
try:
with open("/proc/mounts", "r") as f:
for line in f:
parts = line.split()
if len(parts) >= 2:
mount_point = parts[1]
# Filter out virtual filesystems
if (
not mount_point.startswith("/proc")
and not mount_point.startswith("/sys")
and not mount_point.startswith("/dev")
):
mount_points.append(mount_point)
except (OSError, IOError):
# Fallback to common locations
mount_points = ["/", "/home"]
return mount_points
def get_disk_usage(self, path: str) -> Dict:
"""Get disk usage for a path"""
try:
if hasattr(os, "statvfs"):
# Unix-like systems
stat = os.statvfs(path)
total = stat.f_frsize * stat.f_blocks
used = stat.f_frsize * (stat.f_blocks - stat.f_bavail)
free = stat.f_frsize * stat.f_bavail
else:
# Windows
import ctypes
total_bytes = ctypes.c_ulonglong(0)
free_bytes = ctypes.c_ulonglong(0)
ctypes.windll.kernel32.GetDiskFreeSpaceExW(
ctypes.c_wchar_p(path),
None,
ctypes.byref(total_bytes),
ctypes.byref(free_bytes),
)
total = total_bytes.value
free = free_bytes.value
used = total - free
usage_percent = (used / total * 100) if total > 0 else 0
return {
"path": path,
"total_gb": round(total / (1024**3), 2),
"used_gb": round(used / (1024**3), 2),
"free_gb": round(free / (1024**3), 2),
"usage_percent": round(usage_percent, 2),
"status": self._get_status(usage_percent),
}
except Exception as e:
return {"path": path, "error": str(e), "status": "error"}
def _get_status(self, usage_percent: float) -> str:
"""Get status based on usage percentage"""
if usage_percent >= self.critical_threshold:
return "critical"
elif usage_percent >= self.warning_threshold:
return "warning"
else:
return "ok"
def monitor_all(self) -> Dict:
"""Monitor all mount points"""
mount_points = self.get_mount_points()
results = {"timestamp": datetime.now().isoformat(), "platform": self.platform, "drives": []}
for mount_point in mount_points:
usage = self.get_disk_usage(mount_point)
results["drives"].append(usage)
# Calculate summary
critical_count = sum(1 for d in results["drives"] if d.get("status") == "critical")
warning_count = sum(1 for d in results["drives"] if d.get("status") == "warning")
results["summary"] = {
"total_drives": len(results["drives"]),
"critical": critical_count,
"warning": warning_count,
"overall_status": (
"critical" if critical_count > 0 else "warning" if warning_count > 0 else "ok"
),
}
return results
def print_status(self, results: Dict):
"""Print status to console"""
print(f"\n{'='*70}")
print(f"DISK MONITOR - {results['timestamp']}")
print(f"{'='*70}")
for drive in results["drives"]:
if "error" in drive:
print(f"\n[X] {drive['path']}: ERROR - {drive['error']}")
continue
path = drive["path"]
usage = drive["usage_percent"]
free_gb = drive["free_gb"]
status = drive["status"]
# Status indicator
if status == "critical":
indicator = "[!] CRITICAL"
elif status == "warning":
indicator = "[!] WARNING"
else:
indicator = "[OK] OK"
# Build usage bar
bar_length = 30
filled = int(bar_length * usage / 100)
bar = "█" * filled + "░" * (bar_length - filled)
print(f"\n{indicator} {path}")
print(f" Usage: [{bar}] {usage}%")
print(f" Free: {free_gb} GB / {drive['total_gb']} GB")
if status == "critical":
print(f" [!] CRITICAL: Disk is {usage}% full!")
elif status == "warning":
print(f" [!] WARNING: Disk is {usage}% full")
# Summary
summary = results["summary"]
print(f"\n{'─'*70}")
print(
f"Summary: {summary['total_drives']} drive(s), "
f"{summary['critical']} critical, {summary['warning']} warning"
)
print(f"Overall Status: {summary['overall_status'].upper()}")
print(f"{'='*70}\n")
def continuous_monitor(self, interval: int = 60):
"""Continuously monitor disk usage at specified interval"""
print(f"\n[*] Monitoring disk usage every {interval} seconds...")
print("Press Ctrl+C to stop\n")
while self.running:
results = self.monitor_all()
self.print_status(results)
# Check for critical issues
if results["summary"]["overall_status"] == "critical":
print("[!] CRITICAL DISK SPACE ISSUES DETECTED!")
print(" Immediate action required!\n")
# Wait for next interval
for _ in range(interval):
if not self.running:
break
time.sleep(1)
def check_thresholds(self) -> bool:
"""Check if any thresholds are exceeded"""
results = self.monitor_all()
return results["summary"]["overall_status"] in ["warning", "critical"]
def get_drive_details(self, path: str) -> Dict:
"""Get detailed information about a specific drive"""
usage = self.get_disk_usage(path)
# Add additional details
details = {**usage}
# Get inode info for Unix
if self.platform != "Windows" and "error" not in usage:
try:
stat = os.statvfs(path)
details["inodes_total"] = stat.f_files
details["inodes_free"] = stat.f_ffree
details["inodes_used"] = stat.f_files - stat.f_ffree
details["inodes_percent"] = round(
(details["inodes_used"] / stat.f_files * 100) if stat.f_files > 0 else 0, 2
)
except (OSError, AttributeError):
pass
return details
def print_alerts(results: Dict):
"""Print only alerts for drives exceeding thresholds"""
summary = results["summary"]
if summary["overall_status"] == "ok":
return
print(f"\n[!] DISK SPACE ALERTS - {results['timestamp']}")
print("=" * 60)
for drive in results["drives"]:
status = drive.get("status")
if status in ["warning", "critical"]:
path = drive["path"]
usage = drive["usage_percent"]
free_gb = drive["free_gb"]
if status == "critical":
print(f"[!] CRITICAL: {path}")
print(f" Usage: {usage}% | Free: {free_gb} GB")
print(" ACTION REQUIRED IMMEDIATELY")
else:
print(f"[!] WARNING: {path}")
print(f" Usage: {usage}% | Free: {free_gb} GB")
print(" Consider cleaning up soon")
print("=" * 60)
def main():
import argparse
parser = argparse.ArgumentParser(description="Monitor disk usage")
parser.add_argument(
"--warning", "-w", type=int, default=80, help="Warning threshold (default: 80%%)"
)
parser.add_argument(
"--critical", "-c", type=int, default=90, help="Critical threshold (default: 90%%)"
)
parser.add_argument("--watch", action="store_true", help="Continuous monitoring mode")
parser.add_argument(
"--interval",
"-i",
type=int,
default=60,
help="Monitoring interval in seconds (default: 60)",
)
parser.add_argument("--json", action="store_true", help="Output as JSON")
parser.add_argument(
"--alerts-only", action="store_true", help="Only show drives exceeding thresholds"
)
parser.add_argument("--output", "-o", help="Save report to file")
args = parser.parse_args()
monitor = DiskMonitor(warning_threshold=args.warning, critical_threshold=args.critical)
if args.watch:
monitor.continuous_monitor(interval=args.interval)
else:
results = monitor.monitor_all()
if args.json:
print(json.dumps(results, indent=2))
elif args.alerts_only:
monitor.print_status(results)
print_alerts(results)
else:
monitor.print_status(results)
if args.output:
with open(args.output, "w") as f:
json.dump(results, f, indent=2)
print(f"[OK] Report saved to {args.output}")
# Exit with error code if thresholds exceeded
if results["summary"]["overall_status"] == "critical":
sys.exit(2)
elif results["summary"]["overall_status"] == "warning":
sys.exit(1)
else:
sys.exit(0)
if __name__ == "__main__":
main()
scripts/organize_files.py
#!/usr/bin/env python3
"""
File organization CLI.
Organize files in a directory using intelligent strategies.
"""
import argparse
import sys
from pathlib import Path
# Add parent directory to path for imports
sys.path.insert(0, str(Path(__file__).parent.parent))
from diskcleaner.core.organizer import FileOrganizer
from diskcleaner.core.rules.archive_rules import RuleEngine
def parse_arguments():
"""
Parse command-line arguments.
Returns:
Parsed arguments namespace.
"""
parser = argparse.ArgumentParser(
description="Organize files using intelligent strategies",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
Examples:
# Preview organization of desktop
python organize_files.py ~/Desktop --strategy desktop --preview
# Organize downloads by date
python organize_files.py ~/Downloads --strategy downloads --execute
# Use general strategy with custom max files
python organize_files.py ~/Documents --strategy general --max-files 100
Available strategies:
desktop - Organize by file type (Images, Documents, Media, etc.)
downloads - Organize by type and date (Documents/2024-04/)
project - Organize by project and semantic grouping
general - Mixed strategy (size, age, type)
""",
)
parser.add_argument(
"path",
nargs="?", # Optional when using --list-strategies
help="Directory path to organize",
)
parser.add_argument(
"--strategy",
"-s",
choices=["desktop", "downloads", "project", "general"],
default="desktop",
help="Organization strategy to use (default: desktop)",
)
parser.add_argument(
"--preview",
"-p",
action="store_true",
help="Preview changes without executing (dry-run mode)",
)
parser.add_argument(
"--execute",
"-e",
action="store_true",
help="Execute organization plan (actually move files)",
)
parser.add_argument(
"--max-files",
"-m",
type=int,
default=50,
help="Maximum files to show in preview (default: 50)",
)
parser.add_argument(
"--verbose",
"-v",
action="store_true",
help="Show detailed progress information",
)
parser.add_argument(
"--list-strategies",
action="store_true",
help="List available strategies and exit",
)
return parser.parse_args()
def list_strategies():
"""List available organization strategies."""
engine = RuleEngine()
print("Available Organization Strategies:")
print("=" * 60)
for name in engine.list_strategies():
strategy = engine.get_strategy(name)
print(f"\n{name.upper()}")
print(f" Description: {strategy.description}")
print(f" Rules: {len(strategy.rules)}")
print("\n" + "=" * 60)
def main():
"""Main entry point."""
args = parse_arguments()
# List strategies mode
if args.list_strategies:
list_strategies()
return 0
# Validate path is provided
if not args.path:
print("Error: path argument is required unless using --list-strategies", file=sys.stderr)
print("Use --list-strategies to see available organization strategies.", file=sys.stderr)
return 1
# Validate path
target_path = Path(args.path).expanduser()
if not target_path.exists():
print(f"Error: Path does not exist: {args.path}", file=sys.stderr)
return 1
if not target_path.is_dir():
print(f"Error: Path is not a directory: {args.path}", file=sys.stderr)
return 1
# Determine mode
dry_run = not args.execute
# If neither --preview nor --execute specified, default to preview
if not args.preview and not args.execute:
print("Note: No mode specified. Defaulting to preview mode.")
print(" Use --execute to actually move files.")
print()
# Create organizer
try:
organizer = FileOrganizer(
target_path=str(target_path),
strategy=args.strategy,
dry_run=dry_run,
)
except ValueError as e:
print(f"Error: {e}", file=sys.stderr)
return 1
# Show strategy info
if args.verbose:
print(f"Strategy: {args.strategy}")
print(f"Target: {target_path}")
print(f"Mode: {'DRY RUN (preview)' if dry_run else 'EXECUTE'}")
print()
# Preview mode
if args.preview or not args.execute:
print(organizer.preview_organization(max_files=args.max_files))
# Preview mode doesn't execute
if dry_run:
print("\nPreview complete. No files were moved.")
print("Use --execute flag to actually organize files.")
return 0
# Execute mode
if args.execute:
print("Executing organization plan...")
print()
# Progress callback
def progress_callback(current, total):
if args.verbose:
percent = (current / total) * 100
print(f"Progress: {current}/{total} ({percent:.1f}%)", end="\r")
# Organize files
try:
organized, skipped, errors = organizer.organize(
progress_callback=progress_callback if args.verbose else None,
)
if args.verbose:
print() # New line after progress
# Show results
print("Organization Complete!")
print(f" Files organized: {organized}")
print(f" Files skipped: {skipped}")
print(f" Errors: {errors}")
if errors > 0:
return 1
return 0
except Exception as e:
print(f"Error during organization: {e}", file=sys.stderr)
return 1
return 0
if __name__ == "__main__":
sys.exit(main())
scripts/package_skill.py
#!/usr/bin/env python3
"""
Improved skill package script
Create self-contained .skill file, ensuring:
1. Include all required files
2. Auto-detect project root directory
3. Verify package integrity
4. Generate installation instructions
"""
import os
import platform
import shutil
import sys
import tempfile
import zipfile
from pathlib import Path
from typing import List, Tuple
# Initialize Windows console encoding
def init_console():
"""Initialize console encoding"""
if platform.system().lower() == "windows":
try:
import ctypes
ctypes.windll.kernel32.SetConsoleOutputCP(65001)
if hasattr(sys.stdout, "buffer"):
import io
sys.stdout = io.TextIOWrapper(
sys.stdout.buffer, encoding="utf-8", errors="replace", line_buffering=True
)
if hasattr(sys.stderr, "buffer"):
sys.stderr = io.TextIOWrapper(
sys.stderr.buffer, encoding="utf-8", errors="replace", line_buffering=True
)
except Exception:
pass
# Initialize at module load time
init_console()
def find_project_root() -> Path:
"""
Intelligently find project root directory
Search strategy:
1. Search upward from current script location
2. Find parent directory containing diskcleaner directory
3. Find directory containing pyproject.toml
"""
# Script location
script_path = Path(__file__).resolve()
# Method 1: Infer from script location
# scripts/disk-cleaner/scripts/package_skill.py
# -> Project root is 3 levels up
candidate = script_path.parent.parent.parent.parent
if (candidate / "diskcleaner").exists():
return candidate
# Method 2: Find pyproject.toml
current = script_path
while current != current.parent:
if (current / "pyproject.toml").exists():
return current
current = current.parent
# Method 3: Use parent of parent of current script directory
# Assuming in skills/disk-cleaner/scripts/
candidate = script_path.parent.parent.parent
if (candidate / "diskcleaner").exists():
return candidate
# Last fallback: use cwd
cwd = Path.cwd()
if (cwd / "diskcleaner").exists():
return cwd
raise FileNotFoundError(
f"Cannot find project root. Please run this script from disk-cleaner repo directory.\n"
f"Current script location: {script_path}\n"
f"Current working directory: {cwd}"
)
def find_skill_root(project_root: Path) -> Path:
"""Find skill root directory"""
# Try common locations
candidates = [
project_root / "skills" / "disk-cleaner",
project_root / "skill",
project_root,
]
for candidate in candidates:
if (candidate / "SKILL.md").exists():
return candidate
raise FileNotFoundError(
f"Cannot find skill root directory (requires SKILL.md file).\n"
f"Tried locations: {[str(c) for c in candidates]}"
)
def get_files_to_include(project_root: Path, skill_root: Path) -> List[Tuple[Path, str]]:
"""
Get list of files to include in package
Returns:
List of (source path, destination relative path)
"""
items = []
# Core modules (from project root)
core_files = [
"diskcleaner/__init__.py",
"diskcleaner/config/__init__.py",
"diskcleaner/config/defaults.py",
"diskcleaner/config/loader.py",
"diskcleaner/core/__init__.py",
"diskcleaner/core/cache.py",
"diskcleaner/core/classifier.py",
"diskcleaner/core/duplicate_finder.py",
"diskcleaner/core/interactive.py",
"diskcleaner/core/process_manager.py",
"diskcleaner/core/progress.py",
"diskcleaner/core/safety.py",
"diskcleaner/core/scanner.py",
"diskcleaner/core/smart_cleanup.py",
"diskcleaner/optimization/__init__.py",
"diskcleaner/optimization/concurrency.py",
"diskcleaner/optimization/delete.py",
"diskcleaner/optimization/hash.py",
"diskcleaner/optimization/memory.py",
"diskcleaner/optimization/profiler.py",
"diskcleaner/optimization/scan.py",
"diskcleaner/platforms/__init__.py",
"diskcleaner/platforms/linux.py",
"diskcleaner/platforms/macos.py",
"diskcleaner/platforms/windows.py",
]
for file_path in core_files:
src = project_root / file_path
if src.exists():
items.append((src, file_path))
else:
print(f"[!] Warning: File does not exist: {src}")
# Skill files (from skill root)
skill_files = [
"SKILL.md",
"INSTALL.md",
"UNIVERSAL_INSTALL.md",
"NO_PYTHON_GUIDE.md",
"PROGRESSIVE_SCAN_SUMMARY.md", # New: Progressive scan guide
"FIXES.md",
"ENCODING_FIX_SUMMARY.md", # New: Encoding fix summary
"AGENT_QUICK_REF.txt",
"scripts/analyze_disk.py",
"scripts/analyze_progressive.py", # New: Progressive scan
"scripts/clean_disk.py",
"scripts/monitor_disk.py",
"scripts/skill_bootstrap.py",
"scripts/check_skill.py",
"scripts/package_skill.py",
"scripts/scheduler.py",
"scripts/qq_cleanup_macos.zsh",
"references/temp_locations.md",
]
for file_path in skill_files:
src = skill_root / file_path
if src.exists():
items.append((src, file_path))
else:
print(f"[!] Warning: File does not exist: {src}")
return items
def create_skill_package(
output_path: Path = None,
project_root: Path = None,
skill_root: Path = None,
verify: bool = True,
) -> Path:
"""
Create skill package
Args:
output_path: Output file path
project_root: Project root directory
skill_root: Skill root directory
verify: Whether to verify package result
Returns:
Path to created .skill file
"""
# Find directories
if project_root is None:
project_root = find_project_root()
print(f"[DIR] Project root: {project_root}")
if skill_root is None:
skill_root = find_skill_root(project_root)
print(f"[DIR] Skill root: {skill_root}")
# Determine output path
if output_path is None:
output_path = skill_root / "disk-cleaner.skill"
print(f"[PKG] Output file: {output_path}")
# Get file list
items = get_files_to_include(project_root, skill_root)
print(f"[i] Files to package: {len(items)}")
# Exclude patterns
exclude_patterns = [
"__pycache__",
"*.pyc",
".pyc",
"*.pyo",
".pytest_cache",
"*.egg-info",
".mypy_cache",
".benchmarks",
"*.py~", # Editor backup files
".DS_Store", # macOS
]
# Create temp directory
with tempfile.TemporaryDirectory() as temp_dir:
skill_dir = Path(temp_dir) / "disk-cleaner"
skill_dir.mkdir()
# Copy files
copied = 0
for src, dst_rel in items:
dst = skill_dir / dst_rel
# Create target directory
dst.parent.mkdir(parents=True, exist_ok=True)
# Check if should be excluded
if any(pattern in str(src) for pattern in exclude_patterns):
continue
# Copy file
if src.is_dir():
shutil.copytree(src, dst, ignore=shutil.ignore_patterns(*exclude_patterns))
else:
shutil.copy2(src, dst)
copied += 1
print(f"[OK] Files copied: {copied}")
# Create README
readme_content = """# Disk Cleaner Skill Package
## Installation
1. Extract this .skill file to your skills directory:
- Windows: `%USERPROFILE%\\.claude\\skills\\disk-cleaner\\`
- macOS/Linux: `~/.claude/skills/disk-cleaner/`
2. Or use in Claude Code:
```
/install-skill path/to/disk-cleaner.skill
```
## Usage
### Analyze disk space
```bash
python scripts/analyze_disk.py
python scripts/analyze_disk.py --path "D:\\Projects"
python scripts/analyze_disk.py --top 50
```
### Clean junk files
```bash
# Preview (safe mode)
python scripts/clean_disk.py --dry-run
# Actual cleaning
python scripts/clean_disk.py --force
# Clean specific categories
python scripts/clean_disk.py --temp --cache --dry-run
```
### Monitor disk usage
```bash
python scripts/monitor_disk.py
python scripts/monitor_disk.py --watch --interval 300
```
## Troubleshooting
If you encounter issues, run diagnostic tools:
```bash
python scripts/check_skill.py
python scripts/skill_bootstrap.py --test-import
```
## Requirements
- Python 3.7+
- No additional dependencies
For more information, see SKILL.md
"""
(skill_dir / "README.txt").write_text(readme_content, encoding="utf-8")
# Create version file
created_time = __import__("datetime").datetime.now().isoformat()
version_content = f"""{{
"name": "disk-cleaner",
"version": "2.1.0",
"description": "High-performance cross-platform disk space monitoring, "
"analysis, and cleaning toolkit with progressive scanning and "
"cross-platform encoding fixes",
"python_requires": ">=3.7",
"created": "{created_time}"
}}
"""
(skill_dir / "skill.json").write_text(version_content, encoding="utf-8")
# Create zip file
with zipfile.ZipFile(output_path, "w", zipfile.ZIP_DEFLATED) as zipf:
for file_path in skill_dir.rglob("*"):
if file_path.is_file():
arcname = file_path.relative_to(skill_dir)
zipf.write(file_path, arcname)
# Display results
size_mb = output_path.stat().st_size / (1024 * 1024)
print("[OK] Package complete!")
print(f" File size: {size_mb:.2f} MB")
print(f" File location: {output_path}")
# Verify
if verify:
print("\n[?] Verifying package content...")
verify_skill_package(output_path)
return output_path
def verify_skill_package(skill_path: Path) -> bool:
"""
Verify skill package integrity
Checks:
1. Whether key files exist
2. Whether Python modules can be imported
3. Whether file structure is correct
"""
with zipfile.ZipFile(skill_path, "r") as zipf:
files = zipf.namelist()
print(f" Total files: {len(files)}")
# Check key files
key_files = [
"SKILL.md",
"skill.json",
"scripts/skill_bootstrap.py",
"scripts/analyze_disk.py",
"scripts/clean_disk.py",
"scripts/monitor_disk.py",
"scripts/check_skill.py",
"diskcleaner/__init__.py",
"diskcleaner/core/progress.py",
"diskcleaner/core/scanner.py",
]
all_ok = True
for key_file in key_files:
if key_file in files:
print(f" [OK] {key_file}")
else:
print(f" [X] {key_file} (missing)")
all_ok = False
if not all_ok:
print("\n[!] Verification failed: Missing key files")
return False
print(" [OK] Verification passed!")
# Try import test
print("\n[TEST] Testing module import...")
try:
# Create temp directory for extraction
with tempfile.TemporaryDirectory() as temp_dir:
temp_path = Path(temp_dir)
with zipfile.ZipFile(skill_path, "r") as zipf:
zipf.extractall(temp_path)
# Add to path and test import
skill_extracted = temp_path / "disk-cleaner"
sys.path.insert(0, str(skill_extracted))
try:
from skill_bootstrap import import_diskcleaner_modules
success, modules = import_diskcleaner_modules()
if success:
print(" [OK] Module import successful")
for name in modules.keys():
print(f" - {name}")
else:
print(" [!] Module import failed, but basic features may still work")
finally:
# Clean up path
if str(skill_extracted) in sys.path:
sys.path.remove(str(skill_extracted))
except Exception as e:
print(f" [!] Import test failed: {e}")
print(" (This may not affect actual usage)")
return True
def main():
import argparse
parser = argparse.ArgumentParser(
description="Create Disk Cleaner skill package",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
Examples:
# Create skill package (default location)
python scripts/package_skill.py
# Specify output path
python scripts/package_skill.py --output ../disk-cleaner-v2.0.skill
# Skip verification
python scripts/package_skill.py --no-verify
# Only verify existing skill package
python scripts/package_skill.py --verify-only disk-cleaner.skill
""",
)
parser.add_argument("--output", "-o", type=Path, help="Output .skill file path")
parser.add_argument("--project-root", type=Path, help="Project root directory (default: auto-detect)")
parser.add_argument("--skill-root", type=Path, help="Skill root directory (default: auto-detect)")
parser.add_argument("--no-verify", action="store_true", help="Skip verification step")
parser.add_argument("--verify-only", type=Path, metavar="SKILL_FILE", help="Only verify existing skill package")
args = parser.parse_args()
if args.verify_only:
print("[?] Verifying skill package...")
success = verify_skill_package(args.verify_only)
sys.exit(0 if success else 1)
try:
output_path = create_skill_package(
output_path=args.output,
project_root=args.project_root,
skill_root=args.skill_root,
verify=not args.no_verify,
)
print(f"\n[*] Skill package created successfully: {output_path}")
sys.exit(0)
except Exception as e:
print(f"\n[X] Error: {e}", file=sys.stderr)
import traceback
traceback.print_exc()
sys.exit(1)
if __name__ == "__main__":
main()
scripts/qq_cleanup_macos.zsh
#!/bin/zsh
set -u
readonly EFFECTIVE_HOME=${QQ_CLEANUP_HOME:-$HOME}
typeset -a QQ_ROOTS TARGET_DIRS
QQ_ROOTS=(
"$EFFECTIVE_HOME/Library/Containers/com.tencent.qq/Data/Library/Application Support/QQ"
"$EFFECTIVE_HOME/Library/Application Support/QQ-NT"
)
usage() {
cat <<'EOF'
Usage:
qq_cleanup_macos.zsh audit
qq_cleanup_macos.zsh clean --older-than-days N --categories Pic,Emoji [--execute]
clean is a preview unless --execute is supplied.
Only Pic and Emoji are accepted cleanup categories.
EOF
}
fail() {
print -u2 -- "error: $1"
exit ${2:-1}
}
require_macos() {
[[ $(uname -s) == Darwin ]] || fail "this script supports macOS only"
}
safe_root() {
local root=$1
[[ -d "$root" && ! -L "$root" ]] || return 1
[[ "$root" == "$EFFECTIVE_HOME/Library/"* ]] || return 1
}
allowed_category_dir() {
local root=$1 dir=$2 category=$3 rel
[[ "$dir" == "$root/"* && -d "$dir" && ! -L "$dir" ]] || return 1
rel=${dir#"$root/"}
case "$category" in
Pic|Emoji)
[[ "$rel" == nt_qq_*/nt_data/"$category" ]] || \
[[ "$category" == Emoji && "$rel" == global/nt_data/Emoji ]]
;;
nt_db)
[[ "$rel" == nt_qq_*/nt_db ]]
;;
Cache|'Code Cache'|GPUCache)
[[ "$rel" == "$category" || "$rel" == Partitions/*/"$category" ]]
;;
nt_temp|log)
[[ "$rel" == nt_qq_*/nt_data/"$category" ]]
;;
*) return 1 ;;
esac
}
discover_dirs() {
local root=$1 category=$2 dir
find "$root" -xdev -maxdepth 5 -type d -name "$category" -print0 2>/dev/null |
while IFS= read -r -d '' dir; do
allowed_category_dir "$root" "$dir" "$category" && print -r -- "$dir"
done
}
audit() {
local root category dir kib found=0
print -- $'Category\tSize(KiB)\tPath'
for root in "${QQ_ROOTS[@]}"; do
[[ -e "$root" ]] || continue
safe_root "$root" || fail "unsafe QQ root: $root"
(( found += 1 ))
for category in Pic Emoji nt_db Cache 'Code Cache' GPUCache nt_temp log; do
while IFS= read -r dir; do
[[ -n "$dir" ]] || continue
kib=$(du -sk "$dir" 2>/dev/null | awk '{print $1}') || fail "cannot measure: $dir"
print -r -- "${category}"$'\t'"${kib:-0}"$'\t'"$dir"
done < <(discover_dirs "$root" "$category")
done
done
(( found > 0 )) || fail "no recognized QQ storage found" 2
}
parse_clean_args() {
local arg
CLEAN_DAYS=''
CLEAN_CATEGORIES=''
CLEAN_EXECUTE=0
shift
while (( $# > 0 )); do
arg=$1
case "$arg" in
--older-than-days)
(( $# >= 2 )) || fail "--older-than-days needs a value"
CLEAN_DAYS=$2
shift 2
;;
--categories)
(( $# >= 2 )) || fail "--categories needs a value"
CLEAN_CATEGORIES=$2
shift 2
;;
--execute)
CLEAN_EXECUTE=1
shift
;;
*) fail "unknown option: $arg" ;;
esac
done
[[ "$CLEAN_DAYS" == <-> && "$CLEAN_DAYS" -gt 0 ]] || fail "days must be a positive integer"
[[ -n "$CLEAN_CATEGORIES" ]] || fail "categories are required"
}
collect_targets() {
local list_file=$1 cutoff=$2 root category dir
: > "$list_file" || return 1
TARGET_DIRS=()
for root in "${QQ_ROOTS[@]}"; do
[[ -e "$root" ]] || continue
safe_root "$root" || return 1
for category in ${(s:,:)CLEAN_CATEGORIES}; do
while IFS= read -r dir; do
[[ -n "$dir" ]] || continue
TARGET_DIRS+=("$dir")
find "$dir" -xdev -type f ! -newermt "$cutoff" -print0 2>/dev/null >> "$list_file" || return 1
done < <(discover_dirs "$root" "$category")
done
done
}
path_is_targeted() {
local file=$1 dir
[[ -f "$file" && ! -L "$file" ]] || return 1
for dir in "${TARGET_DIRS[@]}"; do
[[ "$file" == "$dir/"* ]] && return 0
done
return 1
}
qq_is_stopped() {
command -v pgrep >/dev/null 2>&1 || return 2
pgrep -x QQ >/dev/null 2>&1
case $? in
0) return 1 ;;
1) return 0 ;;
*) return 2 ;;
esac
}
clean() {
local cutoff list_file file count blocks bytes deleted=0 failed=0 residual
parse_clean_args "$@"
local category
for category in ${(s:,:)CLEAN_CATEGORIES}; do
[[ "$category" == Pic || "$category" == Emoji ]] || fail "only Pic and Emoji may be cleaned"
done
cutoff=$(date -v-"${CLEAN_DAYS}"d '+%Y-%m-%d %H:%M:%S' 2>/dev/null) || fail "cannot calculate cutoff"
list_file=$(mktemp "${TMPDIR:-/tmp}/qq-cleanup.XXXXXX") || fail "cannot create temporary list"
CLEAN_LIST_FILE=$list_file
trap 'rm -f -- "$CLEAN_LIST_FILE"' EXIT INT TERM
collect_targets "$list_file" "$cutoff" || fail "cannot collect safe targets"
count=$(tr -cd '\000' < "$list_file" | wc -c | tr -d ' ')
if [[ -s "$list_file" ]]; then
blocks=$(xargs -0 stat -f '%b' < "$list_file" 2>/dev/null | awk '{s+=$1} END {print s+0}') || fail "cannot measure targets"
else
blocks=0
fi
bytes=$(( blocks * 512 ))
print -- "mode=$([[ $CLEAN_EXECUTE -eq 1 ]] && print execute || print preview)"
print -- "cutoff=$cutoff"
print -- "categories=$CLEAN_CATEGORIES"
print -- "files=$count"
print -- "estimated_bytes=$bytes"
if (( CLEAN_EXECUTE == 0 )); then
print -- "No files changed. Re-run with --execute only after approval and after quitting QQ."
return 0
fi
qq_is_stopped
case $? in
0) ;;
1) fail "QQ is running; quit QQ before cleanup" ;;
*) fail "cannot determine whether QQ is running" ;;
esac
while IFS= read -r -d '' file; do
if path_is_targeted "$file" && rm -f -- "$file"; then
(( deleted += 1 ))
else
(( failed += 1 ))
fi
done < "$list_file"
collect_targets "$list_file" "$cutoff" || fail "cleanup finished but verification failed"
residual=$(tr -cd '\000' < "$list_file" | wc -c | tr -d ' ')
print -- "deleted_files=$deleted"
print -- "failed_files=$failed"
print -- "residual_files=$residual"
df -h /System/Volumes/Data 2>/dev/null | tail -n 1 || true
(( failed == 0 && residual == 0 ))
}
main() {
require_macos
case ${1:-} in
audit) audit ;;
clean) clean "$@" ;;
-h|--help|help|'') usage ;;
*) usage; exit 64 ;;
esac
}
main "$@"
scripts/scheduler.py
#!/usr/bin/env python3
"""
Disk Cleaner Scheduler - Automated cleanup scheduling
Supports scheduled cleanup tasks with configurable intervals.
Cross-platform scheduler using platform-specific mechanisms.
"""
import json
import os
import platform
import sys
from datetime import datetime, timedelta
from pathlib import Path
from typing import Dict, List
class CleanupScheduler:
"""Scheduler for automated disk cleanup tasks."""
def __init__(self, config_path: str = None):
self.config_path = config_path or self._get_default_config_path()
self.platform = platform.system()
self.tasks = self._load_tasks()
def _get_default_config_path(self) -> str:
"""Get default configuration file path."""
config_dir = os.path.expanduser("~/.disk-cleaner")
os.makedirs(config_dir, exist_ok=True)
return os.path.join(config_dir, "scheduler.json")
def _load_tasks(self) -> List[Dict]:
"""Load scheduled tasks from configuration."""
if os.path.exists(self.config_path):
with open(self.config_path) as f:
return json.load(f).get("tasks", [])
return []
def _save_tasks(self, tasks: List[Dict]):
"""Save scheduled tasks to configuration."""
os.makedirs(os.path.dirname(self.config_path), exist_ok=True)
with open(self.config_path, "w") as f:
json.dump({"tasks": tasks}, f, indent=2)
def add_task(
self,
name: str,
path: str,
schedule: str,
cleanup_type: str = "smart",
options: Dict = None,
):
"""Add a new scheduled cleanup task."""
task = {
"name": name,
"path": path,
"schedule": schedule,
"cleanup_type": cleanup_type,
"options": options or {},
"enabled": True,
"last_run": None,
"next_run": self._calculate_next_run(schedule),
}
self.tasks.append(task)
self._save_tasks(self.tasks)
def _calculate_next_run(self, schedule: str) -> str:
"""Calculate next run time based on schedule."""
now = datetime.now()
# Simple interval parsing (e.g., "24h" for every 24 hours)
if schedule.endswith("h"):
hours = int(schedule[:-1])
next_run = now + timedelta(hours=hours)
return next_run.isoformat()
# Default to daily
next_run = now + timedelta(days=1)
return next_run.isoformat()
def list_tasks(self) -> List[Dict]:
"""List all scheduled tasks."""
return self.tasks
def remove_task(self, task_name: str):
"""Remove a scheduled task by name."""
self.tasks = [t for t in self.tasks if t["name"] != task_name]
self._save_tasks(self.tasks)
def run_task(self, task: Dict, dry_run: bool = True):
"""Execute a single cleanup task."""
path = task["path"]
cleanup_type = task["cleanup_type"]
print(f"\n{'='*60}")
print(f"Running task: {task['name']}")
print(f"Path: {path}")
print(f"Type: {cleanup_type}")
print(f"Mode: {'DRY RUN' if dry_run else 'CLEAN'}")
print(f"{'='*60}\n")
# Import cleanup modules
sys.path.insert(0, str(Path(__file__).parent.parent))
from diskcleaner.core import SmartCleanupEngine
# Run cleanup
engine = SmartCleanupEngine(path, cache_enabled=True)
report = engine.analyze(include_duplicates=True, safety_check=True)
# Display results
summary = engine.get_summary(report)
print(summary)
if not dry_run:
print("\n[!] Actual cleanup not yet implemented in scheduler mode")
print(" Use --force to enable (coming soon)")
# Update last run time
task["last_run"] = datetime.now().isoformat()
task["next_run"] = self._calculate_next_run(task["schedule"])
self._save_tasks(self.tasks)
def run_due_tasks(self, dry_run: bool = True):
"""Run all tasks that are due."""
now = datetime.now()
due_tasks = []
for task in self.tasks:
if not task.get("enabled", True):
continue
next_run = task.get("next_run")
if next_run and datetime.fromisoformat(next_run) <= now:
due_tasks.append(task)
if not due_tasks:
print("No tasks due to run.")
return
print(f"Running {len(due_tasks)} due task(s)...\n")
for task in due_tasks:
try:
self.run_task(task, dry_run=dry_run)
except Exception as e:
print(f"Error running task '{task['name']}': {e}")
def install_system_scheduler(self):
"""Install as system scheduler (cron/task scheduler)."""
if self.platform == "Linux":
self._install_cron()
elif self.platform == "Darwin":
self._install_launchd()
elif self.platform == "Windows":
self._install_task_scheduler()
else:
print(f"Platform {self.platform} not supported for system scheduling")
def _install_cron(self):
"""Install as cron job on Linux."""
print("Cron installation not yet implemented.")
print("Manual cron entry example:")
print("0 2 * * * /usr/bin/python3 -m diskcleaner.scheduler --run-tasks")
def _install_launchd(self):
"""Install as launchd service on macOS."""
print("Launchd installation not yet implemented.")
def _install_task_scheduler(self):
"""Install as Windows Task Scheduler task."""
print("Task Scheduler installation not yet implemented.")
def print_tasks(tasks: List[Dict]):
"""Print scheduled tasks in a formatted table."""
if not tasks:
print("No scheduled tasks.")
return
print(f"\n{'='*80}")
print(f"{'SCHEDULED TASKS':^80}")
print(f"{'='*80}\n")
for i, task in enumerate(tasks, 1):
status = "✅ Enabled" if task.get("enabled", True) else "❌ Disabled"
print(f"{i}. {task['name']} [{status}]")
print(f" Path: {task['path']}")
print(f" Schedule: {task['schedule']}")
print(f" Type: {task['cleanup_type']}")
print(f" Last run: {task.get('last_run', 'Never')}")
print(f" Next run: {task.get('next_run', 'Not scheduled')}")
print()
def main():
# Fix Windows console encoding for emoji support
import sys
if sys.platform == "win32":
import codecs
sys.stdout = codecs.getwriter("utf-8")(sys.stdout.buffer, "strict")
sys.stderr = codecs.getwriter("utf-8")(sys.stderr.buffer, "strict")
import argparse
parser = argparse.ArgumentParser(description="Disk Cleaner Scheduler")
parser.add_argument("--config", "-c", help="Configuration file path")
subparsers = parser.add_subparsers(dest="command", help="Commands")
# Add task
add_parser = subparsers.add_parser("add", help="Add a new scheduled task")
add_parser.add_argument("name", help="Task name")
add_parser.add_argument("path", help="Path to clean")
add_parser.add_argument("schedule", help="Schedule (e.g., 24h for every 24 hours)")
add_parser.add_argument(
"--type",
"-t",
default="smart",
choices=["smart", "temp", "cache", "logs"],
help="Cleanup type (default: smart)",
)
# List tasks
subparsers.add_parser("list", help="List scheduled tasks")
# Remove task
remove_parser = subparsers.add_parser("remove", help="Remove a task")
remove_parser.add_argument("name", help="Task name to remove")
# Run tasks
run_parser = subparsers.add_parser("run", help="Run due tasks")
run_parser.add_argument(
"--force", action="store_true", help="Actually delete files (disables dry-run)"
)
# Install system scheduler
subparsers.add_parser("install", help="Install as system scheduler")
args = parser.parse_args()
if not args.command:
parser.print_help()
return 0
scheduler = CleanupScheduler(config_path=args.config)
if args.command == "add":
scheduler.add_task(
name=args.name, path=args.path, schedule=args.schedule, cleanup_type=args.type
)
print(f"[OK] Task '{args.name}' added successfully")
print(f" Schedule: {args.schedule}")
print(f" Next run: {scheduler.tasks[-1]['next_run']}")
elif args.command == "list":
tasks = scheduler.list_tasks()
print_tasks(tasks)
elif args.command == "remove":
scheduler.remove_task(args.name)
print(f"[OK] Task '{args.name}' removed")
elif args.command == "run":
dry_run = not args.force
scheduler.run_due_tasks(dry_run=dry_run)
elif args.command == "install":
scheduler.install_system_scheduler()
return 0
if __name__ == "__main__":
sys.exit(main())
scripts/skill_bootstrap.py
#!/usr/bin/env python3
"""
Skill Bootstrap Module - Intelligent Bootstrap Module
This module ensures disk-cleaner skill package runs correctly in any environment,
without requiring pre-installed diskcleaner package.
Features:
- Auto-detect skill package location
- Dynamically add module paths to sys.path
- Cross-platform compatibility handling
- Graceful error handling and fallback options
- Environment detection and diagnostic information
"""
import os
import platform
import sys
from pathlib import Path
from typing import Any, Optional, Tuple
# Safe fallback characters for emoji (for environments that don't support emoji)
EMOJI_FALLBACKS = {
"✅": "[OK]",
"❌": "[X]",
"⚠️": "[!]",
"🎉": "[*]",
"📋": "[i]",
"📁": "[DIR]",
"📦": "[PKG]",
"🔐": "[KEY]",
"🧪": "[TEST]",
"🔍": "[?]",
"💡": "[i]",
"❓": "[?]",
}
def safe_print(message: str, file=None):
"""
Safe print function, automatically handles encoding issues
Automatically replaces emoji with ASCII characters in environments like Windows GBK
that don't support emoji
"""
if file is None:
file = sys.stdout
try:
print(message, file=file)
file.flush()
except UnicodeEncodeError:
# Encoding error, replace emoji and Chinese characters
safe_message = message
for emoji, fallback in EMOJI_FALLBACKS.items():
safe_message = safe_message.replace(emoji, fallback)
# If still has encoding issues, try replacing all non-ASCII characters
try:
print(safe_message, file=file)
file.flush()
except UnicodeEncodeError:
# Last resort: keep only ASCII
safe_message = safe_message.encode("ascii", "replace").decode("ascii")
print(safe_message, file=file)
file.flush()
def init_windows_console():
"""
Initialize Windows console, try setting UTF-8 encoding
This needs to be called before importing any modules
"""
if platform.system().lower() == "windows":
try:
# Try setting console code page to UTF-8
import ctypes
import ctypes.wintypes
# Set console output to UTF-8
kernel32 = ctypes.windll.kernel32
kernel32.SetConsoleOutputCP(65001) # CP_UTF8
# Reset stdout/stderr
if hasattr(sys.stdout, "buffer"):
import io
sys.stdout = io.TextIOWrapper(
sys.stdout.buffer, encoding="utf-8", errors="replace", line_buffering=True
)
if hasattr(sys.stderr, "buffer"):
sys.stderr = io.TextIOWrapper(
sys.stderr.buffer, encoding="utf-8", errors="replace", line_buffering=True
)
except Exception:
# Use default settings on failure
pass
class SkillBootstrap:
"""Skill package bootstrap - ensures skill package can run independently"""
def __init__(self):
self.skill_root: Optional[Path] = None
self.platform = platform.system().lower()
self.python_version = sys.version_info
self.debug = os.environ.get("DISK_CLEANER_DEBUG", "").lower() == "true"
def log(self, message: str) -> None:
"""Debug log output"""
if self.debug:
safe_print(f"[Bootstrap] {message}", file=sys.stderr)
def print(self, message: str):
"""Safe print method"""
safe_print(message)
def detect_skill_root(self) -> Optional[Path]:
"""
Intelligently detect skill package root directory - Universal/Platform/IDE agnostic
Search strategy (priority order):
1. Environment variable DISK_CLEANER_SKILL_PATH (manually specified)
2. Parent directory of script location
3. Current working directory and its parents
4. Universal skill directory in user home
5. Platform-specific directories
6. Paths in sys.path
"""
if self.skill_root:
return self.skill_root
# Method 0: Check environment variable (highest priority)
env_path = os.environ.get("DISK_CLEANER_SKILL_PATH")
if env_path:
candidate = Path(env_path)
if self._is_valid_skill_root(candidate):
self.skill_root = candidate
self.log(f"Detected skill root from environment variable: {candidate}")
return candidate
else:
self.log(f"Environment variable path invalid: {env_path}")
# Method 1: Infer from script location
try:
import inspect
frame = inspect.currentframe()
if frame and frame.f_back:
caller_file = frame.f_back.f_globals.get("__file__")
if caller_file:
script_path = Path(caller_file).resolve()
# Parent of scripts/ directory is skill root
if script_path.parent.name == "scripts":
candidate = script_path.parent.parent
if self._is_valid_skill_root(candidate):
self.skill_root = candidate
self.log(f"Detected skill root from script location: {candidate}")
return candidate
except Exception as e:
self.log(f"Script location detection failed: {e}")
# Method 2: Detect from current working directory and its parents
cwd = Path.cwd()
search_in_cwd = [
cwd / "disk-cleaner",
cwd / "skills" / "disk-cleaner",
cwd / ".skills" / "disk-cleaner",
cwd / "agent-skills" / "disk-cleaner",
cwd / ".agent-skills" / "disk-cleaner",
]
# Add parent directories (max 3 levels)
for level, parent in enumerate([cwd, *cwd.parents][:3]):
search_in_cwd.extend(
[
parent / "skills" / "disk-cleaner",
parent / ".skills" / "disk-cleaner",
parent / "agent-skills" / "disk-cleaner",
]
)
for candidate in search_in_cwd:
if self._is_valid_skill_root(candidate):
self.skill_root = candidate
self.log(f"Detected skill root from working directory: {candidate}")
return candidate
# Method 3: Universal skill locations in user home
home = Path.home()
user_skill_dirs = [
home / "skills" / "disk-cleaner",
home / ".skills" / "disk-cleaner",
home / "agent-skills" / "disk-cleaner",
home / ".agent-skills" / "disk-cleaner",
home / "skill-packages" / "disk-cleaner",
]
for candidate in user_skill_dirs:
if self._is_valid_skill_root(candidate):
self.skill_root = candidate
self.log(f"Detected skill root from user skill directory: {candidate}")
return candidate
# Method 4: Platform and IDE specific directories
platform_specific = []
if self.platform == "windows":
# Windows specific
appdata = os.environ.get("APPDATA", "")
localappdata = os.environ.get("LOCALAPPDATA", "")
if appdata:
platform_specific.append(Path(appdata) / "skills" / "disk-cleaner")
if localappdata:
platform_specific.append(Path(localappdata) / "skills" / "disk-cleaner")
else:
# Unix-like (macOS, Linux) specific
platform_specific.extend(
[
home / ".local" / "share" / "skills" / "disk-cleaner",
home / ".config" / "skills" / "disk-cleaner",
Path("/usr/local/share/skills/disk-cleaner"),
Path("/opt/skills/disk-cleaner"),
]
)
# IDE specific directories (universal)
ide_specific = [
home / ".cursor" / "skills" / "disk-cleaner",
home / ".windsurf" / "skills" / "disk-cleaner",
home / ".continue" / "skills" / "disk-cleaner",
home / ".aider" / "skills" / "disk-cleaner",
]
platform_specific.extend(ide_specific)
for candidate in platform_specific:
if self._is_valid_skill_root(candidate):
self.skill_root = candidate
self.log(f"Detected skill root from platform/IDE directory: {candidate}")
return candidate
# Method 5: Check existing paths in sys.path
for path_entry in sys.path:
if path_entry and path_entry not in ["", "."]:
test_path = Path(path_entry)
# Check if directly in skill root
if self._is_valid_skill_root(test_path):
self.skill_root = test_path
self.log(f"Detected skill root from sys.path: {test_path}")
return test_path
# Check parent
if self._is_valid_skill_root(test_path.parent):
self.skill_root = test_path.parent
self.log(f"Detected skill root from sys.path parent: {test_path.parent}")
return test_path.parent
self.log("Could not auto-detect skill root directory")
self.log("Please set environment variable DISK_CLEANER_SKILL_PATH=/path/to/skill")
return None
def _is_valid_skill_root(self, path: Path) -> bool:
"""Check if path is a valid skill root directory"""
if not path or not path.exists():
return False
# Check key files and directories
indicators = [
path / "SKILL.md",
path / "scripts",
path / "diskcleaner",
path / "diskcleaner" / "__init__.py",
path / "diskcleaner" / "core" / "progress.py",
]
return all(indicator.exists() for indicator in indicators)
def setup_import_path(self) -> bool:
"""
Setup module import path
Returns:
True if setup successful, False otherwise
"""
skill_root = self.detect_skill_root()
if not skill_root:
self.log("Cannot find skill root, trying installed diskcleaner")
# Try direct import (if already installed)
return self._try_import_installed()
# Add skill root to sys.path
skill_root_str = str(skill_root)
if skill_root_str not in sys.path:
sys.path.insert(0, skill_root_str)
self.log(f"Added to sys.path: {skill_root_str}")
# Verify import
return self._verify_import()
def _try_import_installed(self) -> bool:
"""Try using installed diskcleaner package"""
try:
import diskcleaner
self.log(f"Using installed diskcleaner: {diskcleaner.__version__}")
return True
except (ImportError, AttributeError):
return False
def _verify_import(self) -> bool:
"""Verify diskcleaner module can be imported correctly"""
try:
# Try importing key modules
from diskcleaner.core.progress import ProgressBar
from diskcleaner.core.scanner import DirectoryScanner
self.log("Successfully imported diskcleaner module")
return True
except ImportError as e:
self.log(f"Import failed: {e}")
return False
def get_environment_info(self) -> dict:
"""Get environment diagnostic information"""
info = {
"platform": self.platform,
"python_version": (
f"{self.python_version.major}."
f"{self.python_version.minor}.{self.python_version.micro}"
),
"python_executable": sys.executable,
"skill_root": str(self.skill_root) if self.skill_root else None,
"sys_path": sys.path[:5], # First 5 paths
}
# Check key modules
info["modules"] = {}
for module_name in ["diskcleaner", "diskcleaner.core.progress", "diskcleaner.core.scanner"]:
try:
__import__(module_name)
info["modules"][module_name] = "available"
except ImportError:
info["modules"][module_name] = "missing"
return info
def diagnose_import_failure(self) -> str:
"""Diagnose import failure reason and provide fix suggestions"""
lines = [
"=" * 60,
"DISK CLEANER SKILL PACKAGE DIAGNOSTIC REPORT",
"=" * 60,
]
info = self.get_environment_info()
# Basic info
lines.extend(
[
"",
"[i] Environment Info:",
f" Platform: {info['platform']}",
f" Python: {info['python_version']}",
f" Python path: {info['python_executable']}",
]
)
# Skill root
if info["skill_root"]:
lines.append(f" Skill root: {info['skill_root']}")
else:
lines.append(" Skill root: Not found [!]")
# Module status
lines.append("")
lines.append("[PKG] Module Status:")
for module, status in info["modules"].items():
icon = "[OK]" if status == "available" else "[X]"
lines.append(f" {icon} {module}: {status}")
# Diagnostic suggestions
lines.append("")
lines.append("[i] Fix Suggestions:")
if not info["skill_root"]:
lines.extend(
[
"",
"Skill root not found. Please try the following methods:",
"",
"Method 1: Ensure running script from correct directory",
" cd skills/disk-cleaner/scripts",
" python analyze_disk.py",
"",
"Method 2: Add skills/disk-cleaner to PYTHONPATH",
" export PYTHONPATH=/path/to/skills/disk-cleaner:$PYTHONPATH",
"",
"Method 3: Reinstall skill package",
" Ensure extracted to correct directory",
]
)
elif info["modules"].get("diskcleaner") == "missing":
lines.extend(
[
"",
"diskcleaner module missing. Please check:",
" 1. Whether skill package completely extracted",
f" 2. Whether diskcleaner directory exists at: {info['skill_root']}",
" 3. Whether directory contains __init__.py file",
]
)
lines.append("")
lines.append("=" * 60)
return "\n".join(lines)
def setup_stdout_encoding(self) -> None:
"""
Intelligently set stdout encoding
Cross-platform handling:
- Windows: Try UTF-8, fallback to system default
- Unix: Default to UTF-8
- Handle non-TTY environments (redirection, pipes)
"""
if not sys.stdout.isatty():
# Non-interactive environment, use default encoding
return
if self.platform == "windows":
try:
# Windows: Try setting to UTF-8
if hasattr(sys.stdout, "buffer"):
import io
# First try using UTF-8
try:
# Test if UTF-8 is available
test_writer = io.TextIOWrapper(
sys.stdout.buffer, encoding="utf-8", errors="strict"
)
# Try writing an emoji test
test_writer.write("\u2705")
test_writer.flush()
# If successful, use UTF-8
sys.stdout = io.TextIOWrapper(
sys.stdout.buffer,
encoding="utf-8",
errors="replace", # Use replace to avoid subsequent errors
)
if hasattr(sys.stderr, "buffer"):
sys.stderr = io.TextIOWrapper(
sys.stderr.buffer, encoding="utf-8", errors="replace"
)
self.log("Set Windows console to UTF-8 encoding")
except (UnicodeEncodeError, OSError):
# UTF-8 unavailable, use system default encoding (usually GBK)
self.log("UTF-8 unavailable, using system default encoding")
# Don't modify stdout, keep system default
except Exception as e:
self.log(f"Encoding setup failed, using system default: {e}")
# On failure, do nothing and use system default
# Unix systems usually default to UTF-8, no special handling needed
# Global bootstrap instance
_bootstrap_instance: Optional[SkillBootstrap] = None
def get_bootstrap() -> SkillBootstrap:
"""Get bootstrap instance (singleton pattern)"""
global _bootstrap_instance
if _bootstrap_instance is None:
_bootstrap_instance = SkillBootstrap()
return _bootstrap_instance
def setup_skill_environment(
require_modules: bool = True, fix_encoding: bool = True
) -> Tuple[bool, Optional[SkillBootstrap]]:
"""
Setup skill runtime environment
Args:
require_modules: If True, display diagnostics and exit when module import fails
fix_encoding: If True, automatically fix stdout encoding
Returns:
(Success flag, bootstrap instance)
Example:
>>> success, bootstrap = setup_skill_environment()
>>> if not success:
>>> sys.exit(1)
"""
bootstrap = get_bootstrap()
# Fix encoding
if fix_encoding:
bootstrap.setup_stdout_encoding()
# Setup import path
success = bootstrap.setup_import_path()
if require_modules and not success:
print(bootstrap.diagnose_import_failure(), file=sys.stderr)
return False, bootstrap
return success, bootstrap
def import_diskcleaner_modules():
"""
Convenience function to import diskcleaner modules
Returns:
(Success flag, modules dictionary)
Example:
>>> success, modules = import_diskcleaner_modules()
>>> if success:
>>> ProgressBar = modules['ProgressBar']
>>> DirectoryScanner = modules['DirectoryScanner']
"""
success, bootstrap = setup_skill_environment(require_modules=False)
if not success:
return False, {}
modules = {}
try:
from diskcleaner.config import Config
from diskcleaner.core.cache import CacheManager
from diskcleaner.core.classifier import FileClassifier
from diskcleaner.core.progress import ProgressBar
from diskcleaner.core.safety import SafetyChecker
from diskcleaner.core.scanner import DirectoryScanner
from diskcleaner.core.duplicate_finder import DuplicateFinder
modules.update(
{
"ProgressBar": ProgressBar,
"DirectoryScanner": DirectoryScanner,
"Config": Config,
"CacheManager": CacheManager,
"FileClassifier": FileClassifier,
"SafetyChecker": SafetyChecker,
"DuplicateFinder": DuplicateFinder,
}
)
return True, modules
except ImportError as e:
bootstrap.log(f"Module import failed: {e}")
return False, modules
# When running as script directly, display diagnostic information
if __name__ == "__main__":
# Initialize console encoding on Windows
init_windows_console()
import argparse
parser = argparse.ArgumentParser(description="Disk Cleaner skill package diagnostic tool")
parser.add_argument("--debug", action="store_true", help="Show debug information")
parser.add_argument("--test-import", action="store_true", help="Test module import")
args = parser.parse_args()
if args.debug:
os.environ["DISK_CLEANER_DEBUG"] = "true"
bootstrap = get_bootstrap()
if args.test_import:
safe_print("Testing module import...")
success, modules = import_diskcleaner_modules()
if success:
safe_print("[OK] Module import successful!")
for name in modules.keys():
safe_print(f" - {name}")
else:
safe_print("[X] Module import failed!")
safe_print(bootstrap.diagnose_import_failure())
sys.exit(1)
else:
safe_print(bootstrap.diagnose_import_failure())
scripts/test_wizard.py
#!/usr/bin/env python3
"""
Test script for Interactive Wizard
Tests the wizard functionality without requiring user interaction.
"""
import sys
from pathlib import Path
# Add parent directory to path
SCRIPT_DIR = Path(__file__).parent.parent
sys.path.insert(0, str(SCRIPT_DIR))
from scripts.interactive_wizard import InteractiveWizard
def test_wizard_initialization():
"""Test wizard initialization."""
print("Testing wizard initialization...")
wizard = InteractiveWizard(".")
assert wizard.target_path.exists(), "Target path should exist"
assert wizard.config is not None, "Config should be loaded"
assert wizard.engine is not None, "Engine should be initialized"
assert wizard.ui is not None, "UI should be initialized"
print("[OK] Wizard initialization successful")
def test_scan_mode_config():
"""Test scan mode configuration."""
print("\nTesting scan mode configuration...")
wizard = InteractiveWizard(".")
# Test all scan modes
modes = ["1", "2", "3", "4", "5"]
expected = ["quick", "standard", "deep", "progressive", "custom"]
for mode, expected_name in zip(modes, expected):
result = wizard._get_scan_mode_config(mode)
assert result == expected_name, f"Mode {mode} should map to {expected_name}"
display_name = wizard._get_scan_mode_name(result)
print(f"[OK] Mode {mode}: {result} ({display_name})")
def test_size_formatting():
"""Test size formatting."""
print("\nTesting size formatting...")
wizard = InteractiveWizard(".")
test_cases = [
(100, "100 B"),
(1024, "1.00 KB"),
(1048576, "1.00 MB"),
(1073741824, "1.00 GB"),
(1099511627776, "1.00 TB"),
]
for size_bytes, expected in test_cases:
result = wizard._format_size(size_bytes)
assert result == expected, f"Size {size_bytes} should format as {expected}, got {result}"
print(f"[OK] {size_bytes:,} bytes -> {result}")
def test_risk_emoji():
"""Test risk emoji mapping (ASCII-safe)."""
print("\nTesting risk level indicators...")
wizard = InteractiveWizard(".")
test_cases = [
("safe", "OK"),
("confirm_needed", "!"),
("protected", "X"),
("unknown", "?"),
]
for risk, expected in test_cases:
result = wizard._get_risk_emoji(risk)
assert result == expected, f"Risk {risk} should map to {expected}"
print(f"[OK] Risk '{risk}': {result}")
def test_scan_mode_parameters():
"""Test scan mode parameter setup."""
print("\nTesting scan mode parameters...")
from diskcleaner.core.scanner import DirectoryScanner
from diskcleaner.config import Config
config = Config.load()
# Quick scan
scanner_quick = DirectoryScanner(".", config=config, max_files=10000, max_seconds=1)
assert scanner_quick.max_files == 10000, "Quick scan should limit files"
assert scanner_quick.max_seconds == 1, "Quick scan should limit time"
print("[OK] Quick scan: 10k files, 1 second")
# Standard scan
scanner_std = DirectoryScanner(".", config=config, max_files=100000, max_seconds=120)
assert scanner_std.max_files == 100000, "Standard scan should limit files"
assert scanner_std.max_seconds == 120, "Standard scan should limit time"
print("[OK] Standard scan: 100k files, 120 seconds")
# Deep scan
scanner_deep = DirectoryScanner(".", config=config, max_files=None, max_seconds=None)
# Note: DirectoryScanner sets defaults if None is passed
# Check if it allows very high limits instead of None
print(f"[OK] Deep scan: max_files={scanner_deep.max_files}, max_seconds={scanner_deep.max_seconds}")
# Progressive scan
scanner_prog = DirectoryScanner(".", config=config, cache_enabled=True)
assert scanner_prog.cache_enabled is True, "Progressive scan should use cache"
print("[OK] Progressive scan: cache enabled")
def main():
"""Run all tests."""
print("=" * 60)
print("Interactive Wizard Test Suite")
print("=" * 60)
try:
test_wizard_initialization()
test_scan_mode_config()
test_size_formatting()
test_risk_emoji()
test_scan_mode_parameters()
print("\n" + "=" * 60)
print("All tests passed!")
print("=" * 60)
return 0
except AssertionError as e:
print(f"\n[FAILED] {e}")
return 1
except Exception as e:
print(f"\n[ERROR] {e}")
import traceback
traceback.print_exc()
return 1
if __name__ == "__main__":
sys.exit(main())
SKILL.md
---
name: disk-cleaner
description: "Cross-platform disk space management toolkit with intelligent optimization. REQUIREMENTS: Python 3.7+. UNIVERSAL COMPATIBILITY: Works with ALL AI IDEs (Cursor, Windsurf, Continue, Aider, Claude Code, etc.). PLATFORM-INDEPENDENT: Works at any location - global, project, or user level. SELF-CONTAINED: No pip install needed, includes intelligent bootstrap. KEY FEATURES: (1) PROGRESSIVE SCANNING: Quick sample (1s) + Progressive mode for large disks, (2) INTELLIGENT BOOTSTRAP: Auto-detection of skill location and auto-import of modules, (3) CROSS-PLATFORM ENCODING: Safe emoji/Unicode handling on all platforms, (4) DIAGNOSTIC TOOLS: check_skill.py for quick verification, (5) OPTIMIZED SCANNING: 3-5x faster with os.scandir(), concurrent scanning, intelligent sampling. AGENT WORKFLOW: (1) Check Python, (2) Find skill package (20+ locations auto-detected), (3) Run diagnostics, (4) Use progressive scanning for large disks. The skill package includes all optimization modules - no features are lost!"
---
# Disk Cleaner Skill - Complete Feature Guide for All Agents
## 🚨 IMPORTANT: Emoji Usage Policy
### For Script Output (Cross-Platform Safety)
- **NEVER use emoji in script output** - All scripts use ASCII-safe characters
- Scripts use: `[OK]`, `[X]`, `[!]`, `[*]`, `[i]`, `[DIR]`, `[FILE]`, `[PKG]`, `[x]`
- This ensures compatibility with Windows GBK and other non-UTF-8 consoles
- **DO NOT modify script output to add emoji** - This will break cross-platform compatibility
### For Agent-to-Human Communication (Recommended)
- **SHOULD use emoji when reporting results to humans** - Makes output more readable
- Use these emoji in your final reports to users:
- `✅` (Success) - Completed operations, successful scans
- `❌` (Error) - Failed operations, critical errors
- `⚠️` (Warning) - Warnings, issues that need attention
- `🔍` (Scanning) - Search/scan operations
- `📊` (Statistics) - Analysis results, statistics
- `📁` (Directory) - Directory-related information
- `📦` (Package) - Package/module information
- `🎉` (Success) - Celebratory messages for successful completion
- `🚨` (Critical) - Critical warnings
- `💡` (Tip) - Suggestions, recommendations
- `📋` (List) - Checklists, summaries
- `🔧` (Tool) - Tools, utilities
- `🌐` (Global) - Cross-platform, universal features
- `🛡️` (Safety) - Safety-related information
- `⚡` (Performance) - Performance improvements
- `📝` (Document) - Documentation
- `🎓` (Learning) - Educational content
- `📞` (Support) - Help, support information
- `📈` (Growth) - Improvements, gains
- `🎯` (Target) - Goals, objectives
- `🚀` (Launch) - Quick start, fast operations
- `🛠️` (Tools) - Tool-related features
**Example:**
```
Script output (ASCII): [OK] Scan completed: 50,000 files in 30 seconds
Your report to human: ✅ Scan completed successfully! Found 50,000 files in 30 seconds
```
---
## 📦 COMPLETE FEATURE LIST (READ THIS FIRST!)
### 🚨 CRITICAL: Progressive Scanning (MANDATORY for Large Disks)
- ✅ **Quick Sample Mode**: 1-second estimation of disk size and scan time
- ✅ **Progressive Scan Mode**: Get partial results in 30 seconds for large disks
- ✅ **Smart Time Limits**: Prevent users from waiting hours
- ✅ **Real-time Feedback**: Progress updates every 2 seconds
- ✅ **Interruptible**: Ctrl+C to get partial results
### 🔧 Intelligent Bootstrap (Auto-Detection & Import)
- ✅ **Auto Location Detection**: Searches 20+ common skill package locations
- ✅ **Environment Variable Support**: DISK_CLEANER_SKILL_PATH override
- ✅ **Auto Module Import**: Automatically imports diskcleaner modules
- ✅ **Fallback Mechanisms**: Works even if some features unavailable
- ✅ **Cross-Platform Python Detection**: Tries both 'python' and 'python3'
### 🌐 Universal Compatibility
- ✅ **All AI IDEs**: Cursor, Windsurf, Continue, Aider, Claude Code, etc.
- ✅ **All Platforms**: Windows, macOS, Linux (including Windows GBK console)
- ✅ **All Installation Levels**: Global, project, user level
- ✅ **No Configuration Needed**: Works out of the box
- ✅ **Cross-Platform Encoding**: All scripts use ASCII-safe output (v2.0+)
### 🛡️ Safety & Reliability
- ✅ **Diagnostic Tool**: check_skill.py - verifies all functionality
- ✅ **Safe Encoding**: All scripts use ASCII characters (no emoji in output)
- ✅ **Safe Defaults**: --dry-run for cleaning, smart limits for scanning
- ✅ **Protected Paths**: Never deletes system directories or executables
- ✅ **Error Handling**: Graceful degradation on errors
- ✅ **GBK/UTF-8 Compatible**: Works on Windows GBK, UTF-8, and all other encodings
### ⚡ Performance Optimizations (ALL INCLUDED)
- ✅ **QuickProfiler**: Fast sampling to estimate scan characteristics
- ✅ **ConcurrentScanner**: Multi-threaded I/O for 3-5x speedup
- ✅ **os.scandir() Optimization**: 3-5x faster than Path.glob
- ✅ **IncrementalCache**: Cache scan results for faster repeat scans
- ✅ **Memory Monitoring**: Auto-adapts based to available memory
- ✅ **Early Stopping**: Configurable file/time limits
- ✅ **Enhanced Cache Detection**: 26+ cache paths (was 8) - 225% improvement
### 🆕 v2.2+ New Features
- ✅ **Duplicate File Detection**: Find and remove duplicate files with adaptive strategies
- ✅ **Growth Trend Analysis**: Track disk usage over time, predict when disk will be full
- ✅ **Interactive Wizard**: Step-by-step guided cleanup with safety confirmations
- ✅ **File Organization**: Intelligent file archival and organization (4 strategies)
- ✅ **Enhanced Scan Limits**: 500K files (was 50K), 120s timeout (was 30s)
- ✅ **Deep Scan Mode**: `--deep-scan` for unlimited scanning
- ✅ **Windows Directory Support**: `--include-windows` for system directory scanning
### 📊 Available Scripts (13+ Total)
**Core Analysis:**
1. **analyze_disk.py** - Disk analysis with smart sampling (enhanced v2.2)
2. **analyze_progressive.py** - Progressive scanning for large disks
3. **find_duplicates.py** - Duplicate file detection (NEW v2.2)
4. **analyze_growth.py** - Growth trend analysis (NEW v2.2)
**Cleaning & Organization:**
5. **clean_disk.py** - Safe junk file cleaning (enhanced cache detection)
6. **interactive_wizard.py** - Interactive guided cleanup (NEW v2.2)
7. **organize_files.py** - File archival and organization (NEW v2.2)
**Monitoring & Diagnostics:**
8. **monitor_disk.py** - Disk usage monitoring
9. **check_skill.py** - Diagnostic tool
**Developer Tools:**
10. **skill_bootstrap.py** - Intelligent bootstrap module
11. **package_skill.py** - Package creation tool
12. **scheduler.py** - Automated scheduling
### macOS QQ media cleanup
Use `scripts/qq_cleanup_macos.zsh` when QQ pictures or emojis consume excessive
space on macOS and chat records must remain intact.
1. Audit QQ storage without changing files:
```zsh
scripts/qq_cleanup_macos.zsh audit
```
2. Preview pictures and emojis older than 90 days:
```zsh
scripts/qq_cleanup_macos.zsh clean --older-than-days 90 --categories Pic,Emoji
```
3. Report the preview and obtain explicit approval. Quit QQ, then repeat the
approved command with `--execute`.
Never select `nt_db`, account roots, preferences, voice messages, videos, or
received files. The script accepts only `Pic` and `Emoji`, defaults to preview,
and refuses execution while QQ is running. Warn that removed local media might
no longer be available in old conversations.
### 🚀 Multi-Agent Acceleration (CRITICAL FOR PERFORMANCE)
**🎯 KEY INSIGHT: Use Sub-Agents for Parallel Processing**
This is one of the MOST POWERFUL features of disk-cleaner when used by AI Agents!
#### Why Use Multiple Agents?
Single-threaded scanning:
```
Agent scans → [Dir1] → [Dir2] → [Dir3] → ... (sequential, slow)
```
Multi-Agent parallel scanning:
```
Main Agent
├─ Sub-Agent-1 scans → [Dir1, Dir2, Dir3] (parallel)
├─ Sub-Agent-2 scans → [Dir4, Dir5, Dir6] (parallel)
└─ Sub-Agent-3 scans → [Dir7, Dir8, Dir9] (parallel)
Result: 3-10x faster! ⚡
```
#### When to Use Multi-Agent Mode?
✅ **ALWAYS use when:**
- Scanning multiple top-level directories (e.g., C:\, D:\, E:\)
- Cleaning multiple user profiles
- Processing large file sets (>100K files)
- Time-critical operations
❌ **Don't use when:**
- Single small directory (<10K files)
- Quick analysis (<30 seconds)
- Simple cleanup tasks
#### How to Implement Multi-Agent Scanning
**Option 1: Use Agent Tool (Recommended for Claude Code)**
```python
# Agent code that spawns sub-agents
from anthropic import Anthropic
def parallel_scan_directories(directories_list):
"""
Scan multiple directories in parallel using sub-agents
"""
# Split directories among sub-agents (3-5 agents optimal)
chunks = split_list(directories_list, n_chunks=3)
# Launch sub-agents in parallel
agents = []
for i, chunk in enumerate(chunks):
agent = Anthropic().agent.create(
name=f"scanner-{i}",
instructions=f"""
Scan these directories: {chunk}
Use disk-cleaner with: --file-limit 50000 --time-limit 60
Return results in JSON format
""",
model="claude-sonnet-4-20250514" # Fast model
)
agents.append(agent)
# Wait for all agents and collect results
results = [agent.wait() for agent in agents]
return merge_results(results)
```
**Option 2: Parallel Subprocess (Platform Independent)**
```python
import subprocess
from concurrent.futures import ThreadPoolExecutor, as_completed
def parallel_scan_subprocess(directories_list):
"""
Scan multiple directories using parallel subprocess calls
Works with ALL AI IDEs that support subprocess
"""
def scan_directory(directory):
"""Scan a single directory"""
cmd = [
'python',
'skills/disk-cleaner/scripts/analyze_disk.py',
'--path', str(directory),
'--file-limit', '50000',
'--json'
]
result = subprocess.run(cmd, capture_output=True, text=True)
return json.loads(result.stdout)
# Use 3-5 parallel workers
with ThreadPoolExecutor(max_workers=4) as executor:
futures = {
executor.submit(scan_directory, d): d
for d in directories_list
}
results = {}
for future in as_completed(futures):
directory = futures[future]
try:
results[directory] = future.result()
except Exception as e:
results[directory] = {"error": str(e)}
return results
# Usage: Scan C:\, D:\, E:\ in parallel
directories = ['C:\\', 'D:\\', 'E:\\']
results = parallel_scan_subprocess(directories)
```
**Option 3: Multi-Platform Agent Team (Advanced)**
For Agent-capable systems (Claude Code, Cursor with Agent support):
```python
# Create agent team for massive parallelism
def create_agent_team_scan(top_level_paths):
"""
Create a team of sub-agents, each handling a portion of the work
"""
team_config = {
"name": "disk-cleaner-team",
"members": [
{
"name": "scanner-1",
"task": f"Scan {top_level_paths[0]} using progressive mode",
"tool_use": "subprocess"
},
{
"name": "scanner-2",
"task": f"Scan {top_level_paths[1]} using progressive mode",
"tool_use": "subprocess"
},
{
"name": "scanner-3",
"task": f"Scan {top_level_paths[2]} using progressive mode",
"tool_use": "subprocess"
}
],
"coordination": "parallel", # All run at once
"aggregation": "merge_results" # Combine results at end
}
return launch_agent_team(team_config)
```
#### Performance Comparison
| Scenario | Single Agent | 3 Sub-Agents | Speedup |
|----------|-------------|--------------|---------|
| 3 disks (1TB each) | ~15 minutes | ~5 minutes | **3x** |
| 10 user profiles | ~20 minutes | ~4 minutes | **5x** |
| 1M files | ~30 minutes | ~6 minutes | **5x** |
| Cache cleanup (26 locations) | ~8 minutes | ~2 minutes | **4x** |
#### Recommended Agent Count
- **Small job** (<50K files): 1 agent (not worth overhead)
- **Medium job** (50K-500K files): 2-3 agents
- **Large job** (500K-2M files): 3-5 agents
- **Massive job** (>2M files): 5-8 agents
**Sweet spot: 3-4 agents** (best balance of speed vs overhead)
#### Best Practices
1. **Divide work logically**: By disk, by user profile, by directory type
2. **Use consistent parameters**: All agents use same scan limits
3. **Merge results carefully**: Deduplicate, sort, format
4. **Handle failures gracefully**: If one agent fails, continue others
5. **Monitor progress**: Track which agents completed
⚠️ **IMPORTANT**: Not all AI IDEs support sub-agents. Fall back to parallel subprocess if unavailable.
### 📚 Documentation (Essential Files Only)
- SKILL.md - This complete guide (READ THIS FIRST)
- README.md - Project overview and quick start
- README_zh.md - Chinese documentation
- CHANGELOG.md - Version history and changes
- AGENT_QUICK_REF.txt - One-page reference for agents
- INSTALL.md - Detailed installation guide
- NO_PYTHON_GUIDE.md - Help for users without Python
- references/temp_locations.md - Platform-specific cache locations
---
## 🎯 AGENT CHECKLIST (Must Follow)
### For ANY Disk Analysis Request:
```
[ ] STEP 1: Check Python availability
[ ] STEP 2: Find skill package (auto-detects 20+ locations)
[ ] STEP 3: Run diagnostics: python scripts/check_skill.py
[ ] STEP 4: Run quick sample: --sample (MANDATORY - do this FIRST)
[ ] STEP 5: Choose scan mode based on estimate
[ ] STEP 6: Inform user of expected time
[ ] STEP 7: Execute scan with appropriate limits
[ ] STEP 8: Show results and offer next steps
```
### For ANY Clean Request:
```
[ ] STEP 1-3: Same as above
[ ] STEP 4: ALWAYS use --dry-run first (MANDATORY)
[ ] STEP 5: Show preview results
[ ] STEP 6: Ask user confirmation before --force
[ ] STEP 7: Execute actual cleaning if confirmed
```
---
## ⚡ PROGRESSIVE SCANNING (CRITICAL FOR LARGE DISKS)
## 🚨 CRITICAL INFORMATION (Read First)
### Universal Compatibility
- ✅ **Works with ALL AI IDEs**: Cursor, Windsurf, Continue, Aider, Claude Code, etc.
- ✅ **Platform Independent**: Windows, macOS, Linux
- ✅ **Installation Agnostic**: Works at global, project, or user level
- ✅ **Self-Contained**: No external dependencies, just Python 3.7+
### The Only Requirement
```python
import subprocess
result = subprocess.run(['python', '--version'], capture_output=True, text=True)
# If this succeeds, you can use this skill
```
---
## ⚡ PROGRESSIVE SCANNING (CRITICAL FOR LARGE DISKS)
### 🚨 AGENT MUST USE FOR LARGE DISKS (>100GB)
**Problem**: Full disk scan on large disks (500GB+) can take HOURS. Users will lose patience.
**Solution**: Use progressive scanning - get results in seconds, not hours!
### 📋 Three Scanning Modes
#### Mode 1: Quick Sample (⚡ FASTEST - 1 Second)
**When to use**: Get instant estimate of directory size and scan time
```bash
python scripts/analyze_disk.py --sample
# OR
python scripts/analyze_progressive.py --sample
```
**Output**:
```json
{
"sample_file_count": 7591,
"sample_size_gb": 17.62,
"files_per_second": 7501.0,
"estimated_time_seconds": 2.0
}
```
**Agent Decision Logic**:
```python
# ALWAYS run quick sample first for unknown disk sizes
result = subprocess.run(
['python', 'scripts/analyze_disk.py', '--sample', '--json'],
capture_output=True,
text=True,
timeout=10,
cwd=skill_path
)
import json
sample = json.loads(result.stdout)
estimated_time = sample.get('estimated_time_seconds', 0)
# Choose next action based on estimate
if estimated_time < 30:
mode = 'full' # Full scan is fine
elif estimated_time < 120:
mode = 'time_limited' # Use time limit
else:
mode = 'progressive' # MUST use progressive mode
```
#### Mode 2: Progressive Scan (🎯 RECOMMENDED FOR LARGE DISKS)
**When to use**: Get partial results in 30 seconds for large disks
```bash
python scripts/analyze_progressive.py --max-seconds 30
```
**Features**:
- ✅ Real-time progress updates every 2 seconds
- ✅ Shows partial results as they're discovered
- ✅ Can interrupt with Ctrl+C and keep results
- ✅ Smart file count limit (50,000 by default)
**Agent Usage**:
```python
def analyze_large_disk_safely(path, max_seconds=30):
"""Safely analyze large disk with time limit"""
result = subprocess.run(
['python', 'scripts/analyze_progressive.py',
'--max-seconds', str(max_seconds),
'--path', str(path)],
capture_output=True,
text=True,
timeout=max_seconds + 10,
cwd=skill_path
)
return result.stdout
```
#### Mode 3: Limited Scan (📊 FAST RESULTS)
**When to use**: Get results quickly with file/time limits
```bash
# Limit by file count (fast)
python scripts/analyze_disk.py --file-limit 10000
# Limit by time (safe)
python scripts/analyze_disk.py --time-limit 30
# Both limits (very fast)
python scripts/analyze_disk.py --file-limit 10000 --time-limit 30
```
### 🎯 AGENT DECISION TREE (CRITICAL - FOLLOW THIS)
```
USER REQUEST: "Analyze my disk"
↓
┌─────────────────────────────────────────┐
│ STEP 1: Quick Sample (MANDATORY) │
│ python scripts/analyze_disk.py --sample │
└─────────────────────────────────────────┘
↓
Get estimated_time from sample
↓
├─ estimated_time < 30 seconds
│ ↓
│ ✅ Use FULL SCAN
│ python scripts/analyze_disk.py
│
├─ estimated_time 30-120 seconds
│ ↓
│ ⚠️ Use TIME LIMIT
│ python scripts/analyze_disk.py --time-limit 60
│ Tell user: "This will take ~X minutes"
│
└─ estimated_time > 120 seconds
↓
🚨 MUST USE PROGRESSIVE MODE
python scripts/analyze_progressive.py --max-seconds 30
Tell user: "Large disk detected - using progressive scan (30 seconds)"
```
### 📝 Required Response Templates
#### When Quick Sample Shows < 30 Seconds
```
✅ Disk analysis will take approximately 2 seconds
Starting full scan...
```
#### When Quick Sample Shows 30-120 Seconds
```
⚠️ Disk analysis will take approximately 3 minutes
Using time-limited scan for faster results...
```
#### When Quick Sample Shows > 120 Seconds
```
🚨 Large disk detected! Full scan would take approximately 5 minutes
Using progressive scan mode to get results in 30 seconds...
(This gives you partial results quickly - you can always do a full scan later)
```
### 💡 COPY-PASTE CODE (USE THIS)
```python
import subprocess
import json
from pathlib import Path
def smart_disk_analysis(disk_path, python_cmd='python'):
"""
SMART disk analysis - automatically chooses best method
THIS IS THE RECOMMENDED WAY for all agents
"""
# Find skill package
skill_path = find_skill_package() # Use your find function
if not skill_path:
return False, "Skill package not found"
# STEP 1: Quick sample (MANDATORY - do this first!)
print("🔍 Quick sampling disk...")
sample_result = subprocess.run(
[python_cmd, 'scripts/analyze_disk.py', '--sample',
'--path', str(disk_path), '--json'],
capture_output=True,
text=True,
timeout=10,
cwd=str(skill_path)
)
if sample_result.returncode != 0:
return False, "Sample failed"
try:
sample = json.loads(sample_result.stdout)
estimated_time = sample.get('estimated_time_seconds', 0)
except:
estimated_time = 0
print(f" Estimated scan time: {estimated_time:.0f} seconds")
# STEP 2: Choose scanning method based on estimate
if estimated_time < 30:
# Small disk - full scan
print("✅ Using full scan (small disk)")
result = subprocess.run(
[python_cmd, 'scripts/analyze_disk.py',
'--path', str(disk_path)],
capture_output=True,
text=True,
timeout=60,
cwd=str(skill_path)
)
elif estimated_time < 120:
# Medium disk - time limited
minutes = estimated_time / 60
print(f"⚠️ Using time-limited scan (~{minutes:.1f} minutes)")
result = subprocess.run(
[python_cmd, 'scripts/analyze_disk.py',
'--path', str(disk_path),
'--time-limit', '60'], # 1 minute max
capture_output=True,
text=True,
timeout=70,
cwd=str(skill_path)
)
else:
# Large disk - PROGRESSIVE MODE (MANDATORY)
print(f"🚨 Large disk detected! Using progressive scan (30 seconds)")
result = subprocess.run(
[python_cmd, 'scripts/analyze_progressive.py',
'--path', str(disk_path),
'--max-seconds', '30',
'--json'],
capture_output=True,
text=True,
timeout=40,
cwd=str(skill_path)
)
if result.returncode != 0:
return False, result.stderr
print(result.stdout)
return True, result.stdout
# USAGE - Just call this function:
success, output = smart_disk_analysis("C:\\")
success, output = smart_disk_analysis("/home/user")
success, output = smart_disk_analysis("D:\\Projects")
```
### ⚠️ COMMON MISTAKES TO AVOID
❌ **DON'T**: Always run full scan without checking disk size first
✅ **DO**: Always run `--sample` first to estimate
❌ **DON'T**: Let users wait hours for large disk scan
✅ **DO**: Use `--max-seconds 30` for large disks
❌ **DON'T**: Ignore estimated time from sample
✅ **DO**: Use estimate to choose appropriate scan mode
❌ **DON'T**: Run analyze_disk.py on 1TB disk without limits
✅ **DO**: Use analyze_progressive.py with --max-seconds
### 📊 Command Reference Card
| Situation | Command | Time | Result |
|-----------|---------|------|--------|
| Unknown size | `--sample` | 1s | Estimate + recommendation |
| < 30 seconds | `analyze_disk.py` | <30s | Full results |
| 30-120 seconds | `--time-limit 60` | 60s | Most results |
| > 120 seconds | `analyze_progressive.py --max-seconds 30` | 30s | Partial results |
| Very large disk | `analyze_progressive.py --max-seconds 60` | 60s | More results |
### 🔍 How Progressive Scan Works
1. **Quick Sample (1 second)**
- Scans as many files as possible in 1 second
- Calculates scan rate (files/second)
- Estimates total scan time
- Gives immediate feedback
2. **Progressive Scan (N seconds)**
- Scans continuously for N seconds
- Shows progress every 2 seconds
- Collects results as it goes
- Returns whatever it found when time is up
- User can interrupt and keep partial results
3. **Smart Stopping**
- Stops automatically when time/file limit reached
- Graceful handling of interruption
- Partial results are still useful
### 🎯 BEST PRACTICE FOR AGENTS
1. **ALWAYS** run `--sample` first
2. **ALWAYS** check estimated_time before choosing mode
3. **ALWAYS** inform user about expected scan time
4. **ALWAYS** use progressive mode for large disks (>2 minutes)
5. **NEVER** let users wait more than 2 minutes without feedback
---
---
## 🎯 UNIVERSAL AGENT WORKFLOW
This workflow works on ANY platform, in ANY AI IDE, at ANY location.
### STEP 1: Verify Python
```python
import subprocess
import sys
def verify_python():
"""Check if Python 3.7+ is available - PLATFORM AGNOSTIC"""
try:
# Try 'python' first (Windows, some Unix)
result = subprocess.run(
['python', '--version'],
capture_output=True,
text=True,
timeout=5
)
if result.returncode == 0:
return True, result.stderr.strip() or result.stdout.strip()
except FileNotFoundError:
pass
try:
# Try 'python3' (macOS, Linux)
result = subprocess.run(
['python3', '--version'],
capture_output=True,
text=True,
timeout=5
)
if result.returncode == 0:
return True, result.stderr.strip() or result.stdout.strip()
except FileNotFoundError:
pass
return False, "Python not found"
# EXECUTE
python_available, version_info = verify_python()
if not python_available:
print("❌ Python 3.7+ required but not found")
print("Install from: https://www.python.org/downloads/")
print("See: NO_PYTHON_GUIDE.md for platform-specific instructions")
sys.exit(1)
print(f"✅ Python available: {version_info}")
```
### STEP 2: Locate Skill Package
```python
from pathlib import Path
import os
def find_skill_package():
"""
Find disk-cleaner skill package - LOCATION INDEPENDENT
Searches in order of priority:
1. Current working directory
2. Project-level: ./skills/, ./.skills/, ./agent-skills/
3. User-level: ~/.skills/, ~/.agent-skills/, ~/skill-packages/
4. Common AI IDE locations
5. Parent directories
"""
# Get python command (python or python3)
python_cmd = 'python' if os.name == 'nt' else 'python3'
# Search locations - PLATFORM & IDE AGNOSTIC
search_locations = []
# 1. Current directory
cwd = Path.cwd()
search_locations.extend([
cwd / 'disk-cleaner',
cwd / 'skills' / 'disk-cleaner',
cwd / '.skills' / 'disk-cleaner',
cwd / 'agent-skills' / 'disk-cleaner',
cwd / '.agent-skills' / 'disk-cleaner',
])
# 2. Parent directories (project root)
for parent in [cwd, *cwd.parents]:
search_locations.extend([
parent / 'skills' / 'disk-cleaner',
parent / '.skills' / 'disk-cleaner',
parent / 'agent-skills' / 'disk-cleaner',
])
# Limit search depth
if len(parent.parts) <= 3:
break
# 3. User home directory
home = Path.home()
search_locations.extend([
home / 'skills' / 'disk-cleaner',
home / '.skills' / 'disk-cleaner',
home / 'agent-skills' / 'disk-cleaner',
home / '.agent-skills' / 'disk-cleaner',
home / 'skill-packages' / 'disk-cleaner',
])
# 4. Platform-specific user directories
if os.name == 'nt': # Windows
appdata = os.environ.get('APPDATA', '')
if appdata:
search_locations.append(Path(appdata) / 'skills' / 'disk-cleaner')
localappdata = os.environ.get('LOCALAPPDATA', '')
if localappdata:
search_locations.append(Path(localappdata) / 'skills' / 'disk-cleaner')
else: # Unix-like (macOS, Linux)
search_locations.extend([
home / '.local' / 'share' / 'skills' / 'disk-cleaner',
home / '.config' / 'skills' / 'disk-cleaner',
Path('/usr/local/share/skills/disk-cleaner'),
])
# 5. AI IDE specific directories (IDE-AGNOSTIC)
# Note: These are examples - actual locations vary
ide_specific = [
# Cursor
home / '.cursor' / 'skills' / 'disk-cleaner',
home / '.cursor' / 'user' / 'skills' / 'disk-cleaner',
# Windsurf
home / '.windsurf' / 'skills' / 'disk-cleaner',
# Continue
home / '.continue' / 'skills' / 'disk-cleaner',
# Generic
home / '.ai-ide' / 'skills' / 'disk-cleaner',
]
search_locations.extend(ide_specific)
# 6. sys.path entries (Python module style)
for path_entry in sys.path:
if path_entry and path_entry not in ['', '.']:
test_path = Path(path_entry) / 'disk-cleaner'
search_locations.append(test_path)
# Remove duplicates and non-existent
search_locations = list(set(search_locations))
# Search for valid skill package
for location in search_locations:
if not location:
continue
try:
# Check for key indicator files
if (location / 'scripts' / 'analyze_disk.py').exists():
return location, f"Found at: {location}"
if (location / 'SKILL.md').exists():
return location, f"Found at: {location}"
except PermissionError:
continue
except Exception:
continue
# Not found - provide helpful message
print("❌ Skill package not found")
print("\nSearched locations:")
for loc in search_locations[:10]: # Show first 10
print(f" - {loc}")
print("\nSolutions:")
print("1. Extract skill package to one of the locations above")
print("2. Or set environment variable: DISK_CLEANER_SKILL_PATH")
print("3. Or provide explicit path when calling functions")
return None, "Not found"
# EXECUTE
skill_path, message = find_skill_package()
if not skill_path:
print(message)
sys.exit(1)
print(f"✅ {message}")
```
### STEP 3: Verify Skill Package
```python
def verify_skill_package(skill_path, python_cmd='python'):
"""Verify skill package integrity - LOCATION INDEPENDENT"""
check_script = skill_path / 'scripts' / 'check_skill.py'
if not check_script.exists():
print(f"❌ Check script not found: {check_script}")
return False
try:
result = subprocess.run(
[python_cmd, str(check_script)],
capture_output=True,
text=True,
timeout=30,
cwd=str(skill_path)
)
# Show verification output
if result.stdout:
print(result.stdout)
if result.returncode == 0:
print("✅ Skill package verified successfully")
return True
else:
print("❌ Skill package verification failed")
if result.stderr:
print(result.stderr)
return False
except subprocess.TimeoutExpired:
print("❌ Verification timed out")
return False
except Exception as e:
print(f"❌ Verification error: {e}")
return False
# Determine python command
python_cmd = 'python' if os.name == 'nt' else 'python3'
# EXECUTE
if not verify_skill_package(skill_path, python_cmd):
sys.exit(1)
```
### STEP 4: Execute Operation
```python
def execute_operation(skill_path, operation, python_cmd='python', **kwargs):
"""
Execute disk cleaner operation - PLATFORM & IDE AGNOSTIC
Args:
skill_path: Path to skill package
operation: 'analyze', 'clean', 'monitor'
python_cmd: 'python' or 'python3'
**kwargs: Operation-specific arguments
"""
operation_map = {
'analyze': 'analyze_disk.py',
'clean': 'clean_disk.py',
'monitor': 'monitor_disk.py',
}
if operation not in operation_map:
print(f"❌ Unknown operation: {operation}")
print(f"Valid operations: {list(operation_map.keys())}")
return False, None
script = skill_path / 'scripts' / operation_map[operation]
cmd = [python_cmd, str(script)]
# Add operation-specific arguments
if operation == 'analyze':
if kwargs.get('path'):
cmd.extend(['--path', str(kwargs['path'])])
if kwargs.get('top'):
cmd.extend(['--top', str(kwargs['top'])])
if kwargs.get('json'):
cmd.append('--json')
elif operation == 'clean':
# ALWAYS use dry-run for safety
if not kwargs.get('force'):
cmd.append('--dry-run')
else:
cmd.append('--force')
if kwargs.get('temp'):
cmd.append('--temp')
if kwargs.get('cache'):
cmd.append('--cache')
if kwargs.get('logs'):
cmd.append('--logs')
elif operation == 'monitor':
if kwargs.get('watch'):
cmd.append('--watch')
if kwargs.get('json'):
cmd.append('--json')
try:
print(f"🔧 Executing: {' '.join(cmd)}")
result = subprocess.run(
cmd,
capture_output=True,
text=True,
timeout=kwargs.get('timeout', 300),
cwd=str(skill_path)
)
# Show output
if result.stdout:
print(result.stdout)
if result.returncode != 0:
if result.stderr:
print(f"❌ Error: {result.stderr}")
return False, None
return True, result.stdout
except subprocess.TimeoutExpired:
print("⚠️ Operation timed out")
return False, None
except Exception as e:
print(f"❌ Execution error: {e}")
return False, None
# EXECUTE
success, output = execute_operation(
skill_path,
operation='analyze',
python_cmd=python_cmd,
path='C:\\Users' if os.name == 'nt' else '/home',
json=True
)
if success:
print("✅ Operation completed successfully")
```
---
## 📋 QUICK REFERENCE (All IDEs)
### ⚠️ CRITICAL: Use Progressive Scanning for Large Disks!
**BEFORE ANY DISK ANALYSIS**:
1. Run `--sample` first to estimate scan time
2. If > 2 minutes estimated, use progressive mode
3. NEVER let users wait more than 2 minutes without feedback
**Quick Reference**:
```bash
# STEP 1: ALWAYS DO THIS FIRST (1 second)
python scripts/analyze_disk.py --sample
# STEP 2: Choose based on estimate
# < 30s: python scripts/analyze_disk.py
# 30-120s: python scripts/analyze_disk.py --time-limit 60
# > 120s: python scripts/analyze_progressive.py --max-seconds 30
```
### User Intent → Operation Mapping
### User Intent → Operation Mapping
| User Says | Operation | Command Template |
|-----------|-----------|------------------|
| "analyze disk" | analyze | `python scripts/analyze_disk.py` |
| "check disk space" | analyze | `python scripts/analyze_disk.py --top 50` |
| "quick scan" | analyze | `python scripts/analyze_disk.py --sample` |
| "large disk analysis" | analyze | `python scripts/analyze_progressive.py --max-seconds 30` |
| "clean temp files" | clean | `python scripts/clean_disk.py --temp --dry-run` |
| "preview cleanup" | clean | `python scripts/clean_disk.py --dry-run` |
| "monitor disk" | monitor | `python scripts/monitor_disk.py` |
| "disk usage" | monitor | `python scripts/monitor_disk.py --json` |
### Progressive Scanning (For Large Disks)
**Problem**: Full disk scan can take hours on large disks (1TB+)
**Solution**: Use progressive scanning with time/file limits
```python
# Quick sample (1 second) - Get instant estimate
subprocess.run(['python', 'scripts/analyze_disk.py', '--sample'])
# Progressive scan (30 seconds) - Get partial results quickly
subprocess.run(['python', 'scripts/analyze_progressive.py',
'--max-seconds', '30'])
# Limited file count (fast)
subprocess.run(['python', 'scripts/analyze_disk.py',
'--file-limit', '10000'])
# Full scan with time limit
subprocess.run(['python', 'scripts/analyze_disk.py',
'--time-limit', '120'])
```
**Recommended workflow for large disks**:
1. First, run `--sample` to get estimate (1 second)
2. If estimate is too long, use `--max-seconds` or `--file-limit`
3. Or use `analyze_progressive.py` for real-time feedback
### Cross-Platform Python Commands
| Platform | Python Command | Check Command |
|----------|---------------|---------------|
| Windows | `python` | `python --version` |
| macOS | `python3` | `python3 --version` |
| Linux | `python3` | `python3 --version` |
### Universal Command Template
```python
# Works on ALL platforms
import os
import subprocess
python_cmd = 'python' if os.name == 'nt' else 'python3'
result = subprocess.run([python_cmd, '--version'], capture_output=True, text=True)
```
---
## 🌐 Multi-IDE Compatibility
This skill package works with ALL AI IDEs that support:
### Supported AI IDEs
- ✅ **Cursor** - Works as project or user-level skill
- ✅ **Windsurf** - Works at any location
- ✅ **Continue** - Works as global or project skill
- ✅ **Aider** - Works as agent tool
- ✅ **Claude Code** - Works as skill
- ✅ **Any AI IDE** - Works via subprocess
### Installation by IDE Type
#### Project-Level Installation
```
your-project/
├── skills/
│ └── disk-cleaner/ ← Extract here
├── src/
└── README.md
```
#### User-Level Installation
```
~/.skills/disk-cleaner/ ← Unix-like
~/agent-skills/disk-cleaner/ ← Alternative
C:\Users\You\skills\disk-cleaner\ ← Windows
```
#### Global Installation
```
/usr/local/share/skills/disk-cleaner/ ← Linux (system-wide)
C:\ProgramData\skills\disk-cleaner\ ← Windows (system-wide)
```
---
## 🔧 IDE-Specific Notes
### Cursor
```python
# Cursor automatically searches for skills in:
# - .cursor/skills/
# - project/skills/
# - ~/.skills/
# No special configuration needed
```
### Windsurf
```python
# Windsurf supports skills at:
# - .windsurf/skills/
# - project/skills/
# Skill works via subprocess, no special setup
```
### Continue
```python
# Continue configuration (if needed):
# {
# "skills": ["./skills/disk-cleaner"]
# }
# But auto-detection works in most cases
```
### Aider
```python
# Use as a tool via subprocess:
# !python skills/disk-cleaner/scripts/analyze_disk.py
```
### Generic/Other IDEs
```python
# The skill includes intelligent auto-detection
# Just extract and use - no configuration needed
```
---
## 🎯 Complete Copy-Paste Template
```python
"""
Universal Disk Cleaner Skill Usage
Works with ALL AI IDEs, on ALL platforms, at ANY location
"""
import subprocess
import sys
import os
from pathlib import Path
def use_disk_cleaner(operation='analyze', **kwargs):
"""
Use disk cleaner skill - UNIVERSAL FUNCTION
Works on:
- All platforms (Windows, macOS, Linux)
- All AI IDEs (Cursor, Windsurf, Continue, etc.)
- All installation levels (global, project, user)
Args:
operation: 'analyze', 'clean', 'monitor'
**kwargs: Operation-specific arguments
Returns:
(success: bool, output: str)
"""
# 1. Determine Python command
python_cmd = 'python' if os.name == 'nt' else 'python3'
# 2. Verify Python
try:
result = subprocess.run(
[python_cmd, '--version'],
capture_output=True,
text=True,
timeout=5
)
if result.returncode != 0:
print("❌ Python not found")
return False, "Python 3.7+ required"
except Exception as e:
print(f"❌ Python check failed: {e}")
return False, str(e)
# 3. Find skill package (intelligent search)
def find_skill():
search_paths = [
# Current directory
Path.cwd() / 'disk-cleaner',
Path.cwd() / 'skills' / 'disk-cleaner',
Path.cwd() / '.skills' / 'disk-cleaner',
# Project root
*[(p / 'skills' / 'disk-cleaner') for p in [Path.cwd(), *Path.cwd().parents][:3]],
# User home
Path.home() / 'skills' / 'disk-cleaner',
Path.home() / '.skills' / 'disk-cleaner',
]
for path in search_paths:
if (path / 'scripts' / 'analyze_disk.py').exists():
return path
return None
skill_path = find_skill()
if not skill_path:
print("❌ Skill package not found")
print("Extract to: skills/disk-cleaner/ or ~/.skills/disk-cleaner/")
return False, "Skill package not found"
# 4. Execute operation
scripts = {
'analyze': 'analyze_disk.py',
'clean': 'clean_disk.py',
'monitor': 'monitor_disk.py',
}
if operation not in scripts:
return False, f"Unknown operation: {operation}"
script = skill_path / 'scripts' / scripts[operation]
cmd = [python_cmd, str(script)]
# Add arguments
if operation == 'analyze':
if kwargs.get('path'):
cmd.extend(['--path', str(kwargs['path'])])
elif operation == 'clean':
cmd.append('--dry-run') # Always safe
elif operation == 'monitor':
if kwargs.get('json'):
cmd.append('--json')
# Run
try:
result = subprocess.run(
cmd,
capture_output=True,
text=True,
timeout=300,
cwd=str(skill_path)
)
return result.returncode == 0, result.stdout
except Exception as e:
return False, str(e)
# USAGE EXAMPLES:
# success, output = use_disk_cleaner('analyze', path='.')
# success, output = use_disk_cleaner('clean')
# success, output = use_disk_cleaner('monitor', json=True)
if __name__ == "__main__":
# Quick test
success, output = use_disk_cleaner('analyze')
print(output)
```
---
## ⚡ PROGRESSIVE SCANNING CHECKLIST (CRITICAL)
### Agent MUST Follow This for All Disk Analysis Requests:
```
[ ] Did you run --sample FIRST to estimate scan time?
[ ] Did you inform user about expected scan time?
[ ] Did you choose appropriate mode based on estimate?
[ ] Did you use progressive mode for >2 minute estimates?
[ ] Did you provide feedback during long scans?
```
### Required Behavior by Disk Size:
**Small Disk (< 30 seconds estimated)**:
- ✅ Run full scan
- ✅ No special handling needed
**Medium Disk (30-120 seconds estimated)**:
- ✅ Use --time-limit
- ✅ Inform user of expected time
- ⚠️ Consider progressive mode if user seems impatient
**Large Disk (> 120 seconds estimated)**:
- 🚨 MUST USE PROGRESSIVE MODE
- 🚨 MUST Inform user about time limit
- ✅ Explain partial results
- ✅ Offer full scan as option
### REQUIRED Code Pattern:
```python
# THIS IS THE REQUIRED PATTERN for all disk analysis:
def safe_disk_analysis(disk_path):
# Step 1: ALWAYS sample first
sample = subprocess.run(
['python', 'scripts/analyze_disk.py', '--sample', '--json'],
capture_output=True,
text=True,
cwd=skill_path
)
import json
data = json.loads(sample.stdout)
estimate = data.get('estimated_time_seconds', 0)
# Step 2: Inform user
if estimate > 120:
print(f"Large disk detected! Estimated: {estimate/60:.1f} minutes")
print("Using progressive scan (30 seconds) for quick results...")
# Step 3: Choose mode
if estimate < 30:
# Full scan
return subprocess.run(['python', 'scripts/analyze_disk.py'])
elif estimate < 120:
# Time limited
return subprocess.run(['python', 'scripts/analyze_disk.py', '--time-limit', '60'])
else:
# Progressive (MANDATORY for large disks)
return subprocess.run(['python', 'scripts/analyze_progressive.py', '--max-seconds', '30'])
```
---
## 🚨 Error Handling (Universal)
### Error: Python not found
```python
# SOLUTION - Platform-independent guidance
import platform
system = platform.system()
if system == "Windows":
print("Install from: https://www.python.org/downloads/")
print("Check 'Add Python to PATH' during installation")
elif system == "Darwin": # macOS
print("Install: brew install python@3.11")
print("Or: https://www.python.org/downloads/macos/")
else: # Linux
print("Install: sudo apt install python3 # Debian/Ubuntu")
print("Or: sudo dnf install python3 # Fedora")
```
### Error: Skill not found
```python
# SOLUTION - Show all searched locations
print("Skill package not found.")
print("Extract to ONE of these locations:")
print(" - ./skills/disk-cleaner/")
print(" - ./disk-cleaner/")
print(" - ~/.skills/disk-cleaner/")
print(" - project/skills/disk-cleaner/")
print("\nOr set: DISK_CLEANER_SKILL_PATH=/path/to/skill")
```
### Error: Permission denied
```python
# SOLUTION - Platform-specific advice
if os.name == 'nt':
print("Run as Administrator if needed")
else:
print("Some directories may require: sudo")
print("Or adjust: chmod +x scripts/*.py")
```
---
## 📝 Environment Variables (Optional)
You can optionally set these to help with auto-detection:
```bash
# Set skill package location (overrides auto-detection)
export DISK_CLEANER_SKILL_PATH=/path/to/skills/disk-cleaner
# Set Python command (overrides auto-detection)
export DISK_CLEANER_PYTHON_CMD=python3
# Enable debug output
export DISK_CLEANER_DEBUG=true
```
---
## 🎓 Best Practices for All Agents
1. **ALWAYS check Python first** - Don't assume it's installed
2. **Use 'python3' on Unix** - Use 'python' on Windows
3. **Search multiple locations** - Don't assume single installation path
4. **Use subprocess with timeout** - Prevent hanging
5. **Capture both stdout and stderr** - Complete error information
6. **Prefer --dry-run for clean** - Safety first
7. **Handle all exceptions** - Graceful degradation
8. **Show helpful error messages** - Guide users to solutions
---
## 🔍 Troubleshooting (Universal)
### Problem: Skill works in one IDE but not another
**Solution**: The skill is IDE-agnostic. Check:
1. Python is accessible from that IDE
2. Skill package is in a searchable location
3. File permissions allow execution
### Problem: Different behavior on different platforms
**Solution**: The skill handles platform differences. Check:
1. Python command (`python` vs `python3`)
2. Path separators (auto-handled by pathlib)
3. File permissions (Unix may need `chmod +x`)
### Problem: Can't find skill package
**Solution**: Run diagnostic:
```bash
python skills/disk-cleaner/scripts/check_skill.py
# Or
python3 skills/disk-cleaner/scripts/check_skill.py
```
---
## 📦 Package Contents (Universal)
```
disk-cleaner/
├── SKILL.md # This file
├── AGENT_QUICK_REF.txt # Quick reference
├── NO_PYTHON_GUIDE.md # Help for users without Python
├── INSTALL.md # Installation guide
├── FIXES.md # What's fixed in v2.0
├── scripts/ # All scripts (universal)
├── diskcleaner/ # Core modules (self-contained)
└── references/ # Platform information
```
---
## ✅ Universal Checklist
Before using this skill in ANY AI IDE:
- [ ] Python 3.7+ installed
- [ ] Skill package extracted to accessible location
- [ ] Can run: `python --version` (or `python3 --version`)
- [ ] Skill package location known (or let it auto-detect)
---
**This skill package works EVERYWHERE - just Python 3.7+ required!**
No IDE-specific configuration needed. No platform-specific setup. No installation level restrictions.
Just extract and use!
UNIVERSAL_INSTALL.md
# Universal Installation Guide
## 🌐 Platform & IDE Independent Installation
This guide works for **ALL platforms** and **ALL AI IDEs**.
---
## 📋 What You Need
- **Python 3.7+** - The ONLY requirement
- **This skill package** - The .skill file or extracted directory
That's it! No other dependencies.
---
## 🚀 Quick Install (3 Steps)
### Step 1: Verify Python
```bash
# Windows
python --version
# macOS/Linux
python3 --version
```
If you see `Python 3.x.x`, you're ready!
If not, install from: https://www.python.org/downloads/
### Step 2: Extract Skill Package
Extract `disk-cleaner.skill` to ONE of these locations:
**Recommended (User-level):**
```bash
# Windows
%USERPROFILE%\skills\disk-cleaner\
# macOS/Linux
~/.skills/disk-cleaner/
```
**Alternative (Project-level):**
```bash
your-project/skills/disk-cleaner/
```
**Any location works!** The skill includes intelligent auto-detection.
### Step 3: Verify Installation
```bash
cd skills/disk-cleaner # Or wherever you extracted it
python scripts/check_skill.py
```
Expected output:
```
✅ All checks passed! Skill package ready to use.
```
---
## 🎯 Installation Locations
The skill works at **ANY** of these levels:
### User Level (Recommended)
```
~/.skills/disk-cleaner/ # Unix-like (macOS, Linux)
~/agent-skills/disk-cleaner/ # Alternative
C:\Users\You\skills\disk-cleaner\ # Windows
```
**Benefits:**
- ✅ Available to all projects
- ✅ Single installation
- ✅ Easy to update
### Project Level
```
your-project/
├── skills/
│ └── disk-cleaner/ ← Extract here
├── src/
└── README.md
```
**Benefits:**
- ✅ Project-specific
- ✅ Version locked
- ✅ Portable with project
### Global/System Level
```
/usr/local/share/skills/disk-cleaner/ # Linux (system-wide)
C:\ProgramData\skills\disk-cleaner\ # Windows (system-wide)
```
**Benefits:**
- ✅ All users can access
- ✅ Centralized management
**Note:** May require admin privileges.
---
## 🤖 AI IDE Compatibility
This skill works with **ALL** AI IDEs:
### Cursor
```bash
# Extract to:
~/.cursor/skills/disk-cleaner/
# OR
your-project/.cursor/skills/disk-cleaner/
```
No configuration needed - Cursor auto-detects.
### Windsurf
```bash
# Extract to:
~/.windsurf/skills/disk-cleaner/
# OR
your-project/skills/disk-cleaner/
```
Works immediately.
### Continue
```bash
# Extract to:
~/.continue/skills/disk-cleaner/
# OR
your-project/skills/disk-cleaner/
```
Optionally add to config.json:
```json
{
"skills": ["./skills/disk-cleaner"]
}
```
### Aider
```bash
# Extract anywhere, then use via:
!python skills/disk-cleaner/scripts/analyze_disk.py
```
### Claude Code
```bash
# Extract to:
~/.claude/skills/disk-cleaner/
# OR
your-project/skills/disk-cleaner/
```
Auto-detected by Claude Code.
### Other AI IDEs
The skill works via subprocess - just extract and use!
---
## 🔧 Environment Variables (Optional)
You can set these to override auto-detection:
```bash
# Specify skill location
export DISK_CLEANER_SKILL_PATH=/path/to/disk-cleaner
# Specify Python command
export DISK_CLEANER_PYTHON_CMD=python3
# Enable debug output
export DISK_CLEANER_DEBUG=true
```
**Windows:**
```cmd
set DISK_CLEANER_SKILL_PATH=C:\path\to\disk-cleaner
set DISK_CLEANER_PYTHON_CMD=python
set DISK_CLEANER_DEBUG=true
```
---
## 📁 Directory Structure (After Extraction)
```
disk-cleaner/
├── SKILL.md # Universal agent guide
├── AGENT_QUICK_REF.txt # Quick reference
├── NO_PYTHON_GUIDE.md # Help without Python
├── INSTALL.md # This file
├── scripts/
│ ├── analyze_disk.py
│ ├── clean_disk.py
│ ├── monitor_disk.py
│ ├── check_skill.py # Diagnostic tool
│ └── skill_bootstrap.py # Auto-detection module
└── diskcleaner/ # Self-contained modules
```
**No additional installation needed!**
---
## ✅ Verification
### Quick Check
```bash
python scripts/check_skill.py
```
### Detailed Check
```bash
# With debug output
DISK_CLEANER_DEBUG=true python scripts/check_skill.py
```
### Test Python Import
```bash
python scripts/skill_bootstrap.py --test-import
```
---
## 🚨 Troubleshooting
### Problem: Python not found
**Solution:** Install Python 3.7+
**Windows:**
1. Download from https://www.python.org/downloads/
2. ✅ Check "Add Python to PATH"
3. Install
**macOS:**
```bash
brew install python@3.11
```
**Linux:**
```bash
sudo apt install python3 # Debian/Ubuntu
sudo dnf install python3 # Fedora
```
### Problem: Skill not found
**Solution:** The skill searches many locations. If not found:
1. **Set environment variable:**
```bash
export DISK_CLEANER_SKILL_PATH=/path/to/disk-cleaner
```
2. **Extract to recommended location:**
```bash
mkdir -p ~/.skills
cp -r disk-cleaner ~/.skills/
```
3. **Run from extracted location:**
```bash
cd /path/to/disk-cleaner
python scripts/check_skill.py
```
### Problem: Permission denied
**Unix-like (macOS/Linux):**
```bash
chmod +x scripts/*.py
```
**Windows:** Run as Administrator if needed
### Problem: Works in terminal but not in IDE
**Solution:** Check IDE can access Python
**Most IDEs:** Just add Python to system PATH
**Specific IDEs:**
- **Cursor:** Settings → Path → Python executable
- **Windsurf:** Settings → Languages → Python
- **Continue:** config.json → pythonPath
---
## 🎓 Usage Examples
### From Terminal
```bash
# Analyze current directory
python scripts/analyze_disk.py
# Preview cleanup
python scripts/clean_disk.py --dry-run
# Monitor disk
python scripts/monitor_disk.py
```
### From Python Script
```python
import subprocess
from pathlib import Path
skill_path = Path("~/skills/disk-cleaner").expanduser()
# Analyze
subprocess.run(
['python', 'scripts/analyze_disk.py'],
cwd=str(skill_path)
)
# Clean preview
subprocess.run(
['python', 'scripts/clean_disk.py', '--dry-run'],
cwd=str(skill_path)
)
```
### From Any AI IDE
The skill is detected automatically in most IDEs.
If not, use subprocess:
```python
!python skills/disk-cleaner/scripts/analyze_disk.py
```
---
## 🔄 Updates
To update the skill:
1. Download new version
2. Extract to same location
3. Overwrite existing files
4. Run `python scripts/check_skill.py` to verify
---
## 📞 Support
If you encounter issues:
1. Run diagnostic: `python scripts/check_skill.py`
2. Enable debug: `DISK_CLEANER_DEBUG=true`
3. Check SKILL.md for troubleshooting
4. See NO_PYTHON_GUIDE.md if you don't have Python
---
## ✨ Features
- ✅ **Platform Independent** - Works everywhere
- ✅ **IDE Agnostic** - Compatible with all AI IDEs
- ✅ **Self-Contained** - No pip install needed
- ✅ **Auto-Detection** - Finds itself automatically
- ✅ **Safe by Default** --dry-run for all operations
- ✅ **Cross-Platform** - Windows, macOS, Linux
---
**That's it! Extract and use - no complex setup required!**
The skill package works everywhere, with every AI IDE, at any installation level.