Delphi_Project_Cleaner.dpr

program Delphi_Project_Cleaner;

 {$APPTYPE GUI}
 {$R 'Library\DP_Cleaner.res'}
uses
  Windows,
  SysUtils,
  Classes,
  StrUtils,
  Math,
  Registry;

const
  BULLET = WideChar($2022);   //Bullet Indent
  APP_PATH_NAME = 'cleandpr.exe';
  // -----------------------------------------------------------------
  // All user-facing strings live here in one place, so wording can be
  // changed or translated without hunting through the code.
  // -----------------------------------------------------------------
  CONSOLE_TITLE_STR             = 'Delphi Project Cleaner';
  HELP_HINT_STR                 = 'Note: Type -help for configuration options.';
  SETTINGS_HEADER_STR           = 'Configuration:';
  HELP_INSTALL_PREFIX_STR       = '  -install     Registers "';
  HELP_INSTALL_SUFFIX_STR       = '" as a shortcut you can type into Explorer''s address bar from any folder,';
  HELP_INSTALL_LINE2_STR        = '               so the cleaner instantly opens and scans whichever folder you''re in.';
  HELP_UNINSTALL_LINE_STR       = '  -uninstall   Removes the address bar shortcut from File Explorer and Startmenu.';
  HELP_ABOUT_LINE_STR           = '  -about       Shows information about this application.';
  HELP_HOME_LINE_STR            = '  0            Return to Clean Mode .';
  CHOICE_PROMPT_STR             = 'Choice: ';
  INSTALL_SUCCESS_PREFIX_STR    = 'Done! Type "';
  INSTALL_SUCCESS_SUFFIX_STR    = '" in Explorer''s address bar any time to clean the current folder.';
  INSTALL_FAIL_STR              = 'Failed to install the address-bar shortcut.';
  UNINSTALL_SUCCESS_STR         = 'Address-bar shortcut removed successfully.';
  UNINSTALL_NOOP_STR            = 'Nothing to remove - the shortcut wasn''t installed.';
  UNRECOGNIZED_OPTION_STR       = 'Invalid choice: ';
  DEFAULT_PAGE_STR              = 'You are now in Clean Mode.';


  ENTER_PATH_PROMPT_STR         = 'Please Delphi enter project path(s), or press Esc to exit.';
  PATH_PROMPT_STR               = 'Path: ';
  NO_PROJECT_CURRENT_DIR_STR    = 'No valid Delphi project found in the current directory.';
  PATH_EMPTY_STR                = 'Path cannot be empty.';
  INVALID_PATH_STR              = 'Invalid path. The directory does not exist.';
  NO_PROJECT_SPECIFIED_PATH_STR = 'No valid Delphi project found in the specified path: ';

  CURRENT_PATH_STR              = 'Current Path: ';
  PROJECTS_LIST_HEADER_STR      = 'Delphi Projects List:';

  SCAN_PROJECTS_STR             = 'Scanning for Delphi projects';
  SCAN_PROJECT_FOLDERS_STR      = 'Scanning project folders';
  SCAN_LEFTOVER_FILES_STR       = 'Scanning for leftover files';
  SCAN_ORPHANED_FILES_STR       = 'Scanning for orphaned files';
  SCAN_HISTORY_FOLDERS_STR      = 'Scanning for build history folders';
  SCAN_COMPLETE_STR             = 'Scanning complete';
  DELETING_FILES_STR            = 'Deleting files';
  REMOVING_EMPTY_FOLDERS_STR    = 'Removing empty folders';
  ERROR_DELETING_PREFIX_STR     = '  Error deleting: ';
  ERROR_DELETING_SEP_STR        = ' - ';

  ALREADY_CLEANED_STR           = 'All selected projects are already clean.';
  DELETED_LIST_HEADER_STR       = 'Deleted File List:';
  OTHER_FILES_STR               = '  Other Files:';
  PRESS_ANY_KEY_STR             = 'Press any key to exit.';

  ERROR_PREFIX_STR              = 'Error: ';
  PRESS_ESC_STR                 = 'Press ESC to exit.';

  // -----------------------------------------------------------------
  // "-about" screen contents.
  // -----------------------------------------------------------------
  ABOUT_TITLE_STR                = 'Delphi Projects Cleaner v2.0';
  ABOUT_DEVELOPER_STR            = 'Developer: Shohanur Rahman';
  ABOUT_PUBLISHER_STR            = 'Publisher: SR Studio 24 - BD';
  ABOUT_RELEASE_DATE_STR         = 'Release Date: August 03, 2026';
  ABOUT_VISIT_STR                = 'To explore more amazing tools from SR Studio 24 - BD, visit:';
  ABOUT_WEBSITE_STR              = 'Publisher Website: https://srstudio24.blogspot.com/';

var  BasePath: string;  DPRFiles: TStringList;



procedure ShowConsole;
begin
  if not AllocConsole then  Exit;
  SetConsoleOutputCP(CP_UTF8);
  SetConsoleTitle(CONSOLE_TITLE_STR);
end;




function JoinPath(const Path1, Path2: string): string;
begin
  Result := IncludeTrailingPathDelimiter(Path1) + Path2;
end;

procedure WriteConsoleLine(const S: string);
var
  hStdOut: THandle;
  Written: DWORD;
  Line: string;
  ConsoleMode: DWORD;
begin
  hStdOut := GetStdHandle(STD_OUTPUT_HANDLE);
  if GetConsoleMode(hStdOut, ConsoleMode) then
  begin
    Line := S + sLineBreak;
    WriteConsoleW(hStdOut, PWideChar(Line), Length(Line), Written, nil);
  end
  else
    Writeln(S);
end;

procedure WriteConsoleText(const S: string);
var
  hStdOut: THandle;
  Written: DWORD;
  ConsoleMode: DWORD;
begin
  hStdOut := GetStdHandle(STD_OUTPUT_HANDLE);
  if GetConsoleMode(hStdOut, ConsoleMode) then
    WriteConsoleW(hStdOut, PWideChar(S), Length(S), Written, nil)
  else
    Write(S);
end;

procedure WriteBlankLine;
begin
  WriteConsoleLine('');
end;

// ---------------------------------------------------------------------
// Cursor position helpers, used to print text below the "Path: " input
// line while keeping the actual typing cursor sitting right after
// "Path: " (see PrintPathPrompt), and to keep the hint block pushed
// out of the way of long/pasted input (see EnsureHintPosition below).
// ---------------------------------------------------------------------
function GetCursorPos: TCoord;
var
  Info: TConsoleScreenBufferInfo;
begin
  if GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), Info) then
    Result := Info.dwCursorPosition
  else
  begin
    Result.X := 0;
    Result.Y := 0;
  end;
end;

procedure SetCursorPos(const Pos: TCoord);
begin
  SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), Pos);
end;

function GetConsoleBufferWidth: SmallInt;
var
  Info: TConsoleScreenBufferInfo;
begin
  if GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), Info) then
    Result := Info.dwSize.X
  else
    Result := 80;
end;

// Clears one full console row (used to erase the hint block from its
// old position before it gets redrawn further down).
procedure ClearRow(Row: SmallInt);
var
  Pos: TCoord;
begin
  Pos.X := 0;
  Pos.Y := Row;
  SetCursorPos(Pos);
  WriteConsoleText(StringOfChar(' ', GetConsoleBufferWidth));
end;


procedure WriteAtRow(Row: SmallInt; const Text: string);
var
  Pos: TCoord;
begin
  Pos.X := 0;
  Pos.Y := Row;
  SetCursorPos(Pos);
  WriteConsoleText(Text);
end;


var  HelpHintShown: Boolean = False; HelpHintPending: Boolean = False; HelpHintTopRow: SmallInt = 0;
procedure EnsureHintPosition;
var
  CurPos: TCoord;
  NewTopRow: SmallInt;
begin
  if not HelpHintPending then
    Exit;

  CurPos := GetCursorPos;

  // Hint block still safely below the typing row - nothing to do.
  if CurPos.Y < HelpHintTopRow then
    Exit;

  NewTopRow := CurPos.Y + 1;

  // Erase the old 3-line block (blank, Note, dashes).
  ClearRow(HelpHintTopRow);
  ClearRow(HelpHintTopRow + 1);
  ClearRow(HelpHintTopRow + 2);

  // Redraw it one row below the current typing row.
  WriteAtRow(NewTopRow, '');
  WriteAtRow(NewTopRow + 1, HELP_HINT_STR);
  WriteAtRow(NewTopRow + 2, StringOfChar('-', Length(HELP_HINT_STR)));

  HelpHintTopRow := NewTopRow;

  // Restore the real typing cursor - all of the above moved it around.
  SetCursorPos(CurPos);
end;


var  LastProgressLen: Integer = 0;
procedure ProgressUpdate(const Caption: string; Percent: Integer);
var
  Line: string;
begin
  if Percent < 0 then Percent := 0;
  if Percent > 100 then Percent := 100;
  Line := Caption + ' ... ' + IntToStr(Percent) + '%';
  WriteConsoleText(#13 + Line + StringOfChar(' ', Max(0, LastProgressLen - Length(Line))));
  LastProgressLen := Length(Line);
end;

procedure ProgressClear;
begin
  if LastProgressLen > 0 then
  begin
    WriteConsoleText(#13 + StringOfChar(' ', LastProgressLen) + #13);
    LastProgressLen := 0;
  end;
end;

procedure PressAnyKeyToExit;
var
  hStdIn: THandle;
  InputRec: TInputRecord;
  NumRead: DWORD;
  VK: Word;
  IsModifierKey: Boolean;
begin
  hStdIn := GetStdHandle(STD_INPUT_HANDLE);
  repeat
    if not ReadConsoleInput(hStdIn, InputRec, 1, NumRead) then
      Break;

    if (InputRec.EventType = KEY_EVENT) and InputRec.Event.KeyEvent.bKeyDown then
    begin
      VK := InputRec.Event.KeyEvent.wVirtualKeyCode;

      IsModifierKey :=
        (VK = VK_SHIFT) or (VK = VK_LSHIFT) or (VK = VK_RSHIFT) or
        (VK = VK_CONTROL) or (VK = VK_LCONTROL) or (VK = VK_RCONTROL) or
        (VK = VK_MENU) or (VK = VK_LMENU) or (VK = VK_RMENU) or
        (VK = VK_LWIN) or (VK = VK_RWIN) or
        (VK = VK_CAPITAL) or (VK = VK_NUMLOCK) or (VK = VK_SCROLL);

      if not IsModifierKey then
        Break;
    end;
  until False;
end;

procedure PressEscToExit;
var
  hStdIn: THandle;
  InputRec: TInputRecord;
  NumRead: DWORD;
  VK: Word;
begin
  hStdIn := GetStdHandle(STD_INPUT_HANDLE);
  repeat
    if not ReadConsoleInput(hStdIn, InputRec, 1, NumRead) then
      Break;

    if (InputRec.EventType = KEY_EVENT) and InputRec.Event.KeyEvent.bKeyDown then
    begin
      VK := InputRec.Event.KeyEvent.wVirtualKeyCode;

      // Check for ESC key
      if VK = VK_ESCAPE then
        Halt(0);
    end;
  until False;
end;
type  TAfterCharProc = procedure;

function ReadLineEsc(out LineOut: string; AfterCharProc: TAfterCharProc = nil): Boolean;
var  hStdIn, hStdOut: THandle; InputRec: TInputRecord; NumRead: DWORD; VK: Word;
  Ch: WideChar; Buffer, TempLine: string; CursorPos: Integer; StartX, StartY: SmallInt;
  ConsoleInfo: TConsoleScreenBufferInfo; OriginalCursor: TCoord;
begin
  Buffer := '';
  CursorPos := 0;
  hStdIn := GetStdHandle(STD_INPUT_HANDLE);
  hStdOut := GetStdHandle(STD_OUTPUT_HANDLE);
  GetConsoleScreenBufferInfo(hStdOut, ConsoleInfo);
  StartX := ConsoleInfo.dwCursorPosition.X;
  StartY := ConsoleInfo.dwCursorPosition.Y;

  repeat
    if not ReadConsoleInput(hStdIn, InputRec, 1, NumRead) then
      Break;

    if (InputRec.EventType = KEY_EVENT) and InputRec.Event.KeyEvent.bKeyDown then
    begin
      VK := InputRec.Event.KeyEvent.wVirtualKeyCode;
      Ch := InputRec.Event.KeyEvent.UnicodeChar;

      if VK = VK_ESCAPE then
      begin
        LineOut := '';
        Result := False;
        Exit;
      end
      else if (VK = VK_RETURN) then
      begin
        WriteConsoleLine('');
        LineOut := Buffer;
        Result := True;
        Exit;
      end
      else if (VK = VK_LEFT) and (CursorPos > 0) then
      begin
        Dec(CursorPos);
        // Move cursor left
        OriginalCursor.X := StartX + CursorPos;
        OriginalCursor.Y := StartY;
        SetConsoleCursorPosition(hStdOut, OriginalCursor);
        if Assigned(AfterCharProc) then
          AfterCharProc;
      end
      else if (VK = VK_RIGHT) and (CursorPos < Length(Buffer)) then
      begin
        Inc(CursorPos);
        // Move cursor right
        OriginalCursor.X := StartX + CursorPos;
        OriginalCursor.Y := StartY;
        SetConsoleCursorPosition(hStdOut, OriginalCursor);
        if Assigned(AfterCharProc) then
          AfterCharProc;
      end
      else if (VK = VK_DELETE) and (CursorPos < Length(Buffer)) then
      begin
        // Delete character at cursor position
        Delete(Buffer, CursorPos + 1, 1);
        // Redraw from cursor position
        TempLine := Copy(Buffer, CursorPos + 1, MaxInt);
        // Move cursor to current position
        OriginalCursor.X := StartX + CursorPos;
        OriginalCursor.Y := StartY;
        SetConsoleCursorPosition(hStdOut, OriginalCursor);
        // Write the rest of the line
        WriteConsoleText(TempLine + ' ');
        // Move cursor back to correct position
        OriginalCursor.X := StartX + CursorPos;
        OriginalCursor.Y := StartY;
        SetConsoleCursorPosition(hStdOut, OriginalCursor);
        if Assigned(AfterCharProc) then
          AfterCharProc;
      end
      else if (VK = VK_BACK) then
      begin
        if CursorPos > 0 then
        begin
          // Delete character before cursor
          Delete(Buffer, CursorPos, 1);
          Dec(CursorPos);
          // Redraw from cursor position
          TempLine := Copy(Buffer, CursorPos + 1, MaxInt);
          OriginalCursor.X := StartX + CursorPos;
          OriginalCursor.Y := StartY;
          SetConsoleCursorPosition(hStdOut, OriginalCursor);
          WriteConsoleText(TempLine + ' ');
          // Move cursor back
          OriginalCursor.X := StartX + CursorPos;
          OriginalCursor.Y := StartY;
          SetConsoleCursorPosition(hStdOut, OriginalCursor);
          if Assigned(AfterCharProc) then
            AfterCharProc;
        end;
      end
      else if (Ch <> #0) and not (Ch < #32) then
      begin
        // Insert character at cursor position
        Insert(Ch, Buffer, CursorPos + 1);
        Inc(CursorPos);
        // Redraw from cursor position
        TempLine := Copy(Buffer, CursorPos, MaxInt);
        OriginalCursor.X := StartX + CursorPos - 1;
        OriginalCursor.Y := StartY;
        SetConsoleCursorPosition(hStdOut, OriginalCursor);
        WriteConsoleText(TempLine);
        // Move cursor to after inserted character
        OriginalCursor.X := StartX + CursorPos;
        OriginalCursor.Y := StartY;
        SetConsoleCursorPosition(hStdOut, OriginalCursor);
        if Assigned(AfterCharProc) then
          AfterCharProc;
      end;
    end;
  until False;

  LineOut := Buffer;
  Result := True;
end;





function HasExtension(const FileName, Extension: string): Boolean;
begin
  Result := EndsText(Extension, FileName);
end;

function IsDprojVariantFile(const FileName: string): Boolean;
var
  P: Integer;
begin
  P := Pos('.dproj.', LowerCase(FileName));
  Result := (P > 1) and (P + Length('.dproj.') <= Length(FileName));
end;

function IsGrouprocVariantFile(const FileName: string): Boolean;
var
  P: Integer;
begin
  // Check for .groupproj. (with 'j' at the end)
  P := Pos('.groupproj.', LowerCase(FileName));
  Result := (P > 1) and (P + Length('.groupproj.') <= Length(FileName));
end;

function RelativeToBase(const FullPath: string): string;
begin
  Result := FullPath;
  if AnsiStartsText(BasePath, Result) then
  begin
    Result := Copy(Result, Length(BasePath) + 1, MaxInt);
    if (Length(Result) > 0) and (Result[1] = '\') then
      Result := Copy(Result, 2, MaxInt);
  end;
end;

procedure FindFilesRecursive(const Path, Extension: string; FileList: TStringList);
var
  SearchRec: TSearchRec;
  FullPath: string;
begin
  if FindFirst(JoinPath(Path, '*'), faAnyFile, SearchRec) = 0 then
  try
    repeat
      if (SearchRec.Name = '.') or (SearchRec.Name = '..') then
        Continue;

      FullPath := JoinPath(Path, SearchRec.Name);

      if (SearchRec.Attr and faDirectory) = faDirectory then
      begin
        FindFilesRecursive(FullPath, Extension, FileList);
      end
      else if HasExtension(SearchRec.Name, Extension) then
      begin
        FileList.Add(FullPath);
      end;
    until FindNext(SearchRec) <> 0;
  finally
    FindClose(SearchRec);
  end;
end;

procedure FindDprojVariantFiles(const Path, BaseName: string; FileList: TStringList);
var
  SearchRec: TSearchRec;
  FullPath: string;
begin
  if FindFirst(JoinPath(Path, '*'), faAnyFile, SearchRec) = 0 then
  try
    repeat
      if (SearchRec.Name = '.') or (SearchRec.Name = '..') then
        Continue;

      FullPath := JoinPath(Path, SearchRec.Name);

      if (SearchRec.Attr and faDirectory) = faDirectory then
        FindDprojVariantFiles(FullPath, BaseName, FileList)
      else if StartsText(BaseName + '.dproj.', SearchRec.Name) then
        FileList.Add(FullPath);
    until FindNext(SearchRec) <> 0;
  finally
    FindClose(SearchRec);
  end;
end;

// Renamed from FindOrphanDprojVariantFiles: now catches both ".dproj.*"
// AND ".grouppro.*" leftover variant files (e.g. .grouppro.local,
// .grouppro.tmp, .grouppro.any...) in a single directory walk.
procedure FindOrphanVariantFiles(const Path: string; FileList: TStringList);
var
  SearchRec: TSearchRec;
  FullPath: string;
begin
  if FindFirst(JoinPath(Path, '*'), faAnyFile, SearchRec) = 0 then
  try
    repeat
      if (SearchRec.Name = '.') or (SearchRec.Name = '..') then
        Continue;

      FullPath := JoinPath(Path, SearchRec.Name);

      if (SearchRec.Attr and faDirectory) = faDirectory then
        FindOrphanVariantFiles(FullPath, FileList)
      else if IsDprojVariantFile(SearchRec.Name) or IsGrouprocVariantFile(SearchRec.Name) then
        FileList.Add(FullPath);
    until FindNext(SearchRec) <> 0;
  finally
    FindClose(SearchRec);
  end;
end;

procedure FindFoldersRecursive(const Path, FolderName: string; FolderList: TStringList;
  MatchPrefix: Boolean = False);
var
  SearchRec: TSearchRec;
  FullPath: string;
  IsMatch: Boolean;
begin
  if FindFirst(JoinPath(Path, '*'), faAnyFile, SearchRec) = 0 then
  try
    repeat
      if (SearchRec.Name = '.') or (SearchRec.Name = '..') then
        Continue;

      if (SearchRec.Attr and faDirectory) = faDirectory then
      begin
        FullPath := JoinPath(Path, SearchRec.Name);

        if MatchPrefix then
          IsMatch := StartsText(FolderName, SearchRec.Name)
        else
          IsMatch := SameText(SearchRec.Name, FolderName);

        if IsMatch then
          FolderList.Add(FullPath);

        FindFoldersRecursive(FullPath, FolderName, FolderList, MatchPrefix);
      end;
    until FindNext(SearchRec) <> 0;
  finally
    FindClose(SearchRec);
  end;
end;

procedure DeleteFolderRecursive(const Path: string);
var
  SearchRec: TSearchRec;
  FullPath: string;
begin
  if FindFirst(JoinPath(Path, '*'), faAnyFile, SearchRec) = 0 then
  try
    repeat
      if (SearchRec.Name = '.') or (SearchRec.Name = '..') then
        Continue;

      FullPath := JoinPath(Path, SearchRec.Name);

      if (SearchRec.Attr and faDirectory) = faDirectory then
        DeleteFolderRecursive(FullPath)
      else
      begin
        SetFileAttributes(PChar(FullPath), FILE_ATTRIBUTE_ARCHIVE);
        DeleteFile(FullPath);
      end;
    until FindNext(SearchRec) <> 0;
  finally
    FindClose(SearchRec);
  end;
  RemoveDir(Path);
end;

procedure DeleteEmptyFolders(const Path: string);
var
  SearchRec: TSearchRec;
  FullPath: string;
  SubDirs: TStringList;
  DirName: string;
  IsEmpty: Boolean;
begin
  SubDirs := TStringList.Create;
  try
    if FindFirst(JoinPath(Path, '*'), faAnyFile, SearchRec) = 0 then
    try
      repeat
        if (SearchRec.Name = '.') or (SearchRec.Name = '..') then
          Continue;

        if (SearchRec.Attr and faDirectory) = faDirectory then
        begin
          FullPath := JoinPath(Path, SearchRec.Name);
          SubDirs.Add(FullPath);
        end;
      until FindNext(SearchRec) <> 0;
    finally
      FindClose(SearchRec);
    end;

    for DirName in SubDirs do  DeleteEmptyFolders(DirName);
    IsEmpty := True;
    if FindFirst(JoinPath(Path, '*'), faAnyFile, SearchRec) = 0 then
    try
      repeat
        if (SearchRec.Name = '.') or (SearchRec.Name = '..') then  Continue;
        IsEmpty := False;
        Break;
      until FindNext(SearchRec) <> 0;
    finally
      FindClose(SearchRec);
    end;

    if IsEmpty then
    begin
      try
        RemoveDir(Path);
      except
      end;
    end;
  finally
    SubDirs.Free;
  end;
end;

function CountNameOccurrences(List: TStringList; const Name: string): Integer;
var  idx: Integer;
begin
  Result := 0;
  for idx := 0 to List.Count - 1 do
    if SameText(List[idx], Name) then
      Inc(Result);
end;


function StripSurroundingQuotes(const S: string): string;
var StartPos, EndPos: Integer;
begin
  Result := S;
  StartPos := 1;
  while (StartPos <= Length(Result)) and (Result[StartPos] = '"') do
   Inc(StartPos);
  EndPos := Length(Result);
  while (EndPos >= 1) and (Result[EndPos] = '"') do
    Dec(EndPos);
  if StartPos <= EndPos then
    Result := Copy(Result, StartPos, EndPos - StartPos + 1)
  else  Result := '';
  Result := Trim(Result);
end;

// ---------------------------------------------------------------------
// "Type a short name in Explorer's address bar" support, the same
// mechanism that makes typing "cmd" in the address bar open a command
// prompt in the current folder. Explorer looks the name up under
// App Paths and launches it with the current folder as the working
// directory - no command-line argument is passed, so the program falls
// back to GetCurrentDir() (see FirstRun logic below) to pick it up.
//
// This is the ONLY installation mechanism the app supports - there is
// no right-click / Send-To context menu integration.
// ---------------------------------------------------------------------

function InstallAppPathsEntry: Boolean;
var
  Reg: TRegistry;
  ExePath, ExeFolder: string;
begin
  Result := False;
  ExePath := ParamStr(0);
  ExeFolder := ExtractFilePath(ExePath);

  Reg := TRegistry.Create(KEY_WRITE);
  try
    Reg.RootKey := HKEY_CURRENT_USER;
    if Reg.OpenKey('Software\Microsoft\Windows\CurrentVersion\App Paths\' + APP_PATH_NAME, True) then
    begin
      Reg.WriteString('', ExePath);          // (Default) = full path to the exe
      Reg.WriteString('Path', ExeFolder);     // helps locate any DLLs next to the exe
      Reg.CloseKey;
      Result := True;
    end;
  finally
    Reg.Free;
  end;
end;

function UninstallAppPathsEntry: Boolean;
var
  Reg: TRegistry;
begin
  Reg := TRegistry.Create(KEY_WRITE);
  try
    Reg.RootKey := HKEY_CURRENT_USER;
    Result := Reg.DeleteKey('Software\Microsoft\Windows\CurrentVersion\App Paths\' + APP_PATH_NAME);
  finally
    Reg.Free;
  end;
end;

function IsAppPathsInstalled: Boolean;
var
  Reg: TRegistry;
begin
  Reg := TRegistry.Create(KEY_READ);
  try
    Reg.RootKey := HKEY_CURRENT_USER;
    Result := Reg.KeyExists('Software\Microsoft\Windows\CurrentVersion\App Paths\' + APP_PATH_NAME);
  finally
    Reg.Free;
  end;
end;

// ---------------------------------------------------------------------
// "-about" screen: shows application/publisher information. Callable
// both from the "-help" configuration menu and directly from the
// default Clean Mode prompt.
// ---------------------------------------------------------------------
procedure ShowAboutBlock;
begin
  WriteConsoleLine(ABOUT_TITLE_STR);
  WriteConsoleLine(StringOfChar('-', Length(ABOUT_TITLE_STR)));
  WriteConsoleLine(ABOUT_DEVELOPER_STR);
  WriteConsoleLine(ABOUT_PUBLISHER_STR);
  WriteConsoleLine(ABOUT_RELEASE_DATE_STR);
  WriteBlankLine;
  WriteConsoleLine(ABOUT_VISIT_STR);
  WriteConsoleLine(ABOUT_WEBSITE_STR);
  WriteConsoleLine(StringOfChar('-', Length(ABOUT_WEBSITE_STR)));
  WriteBlankLine;
end;

// ---------------------------------------------------------------------
// "-help" screen: lets the user install/uninstall the Explorer
// address-bar shortcut ("dpclean"), or view "-about" info, from inside
// the running app, without needing to pass a command-line switch.
// Returns True if the user chose "0" (go back to the normal prompt),
// or False if the user pressed ESC (caller should exit the app).
// ---------------------------------------------------------------------
function ShowHelpMenu: Boolean;
var
  Choice: string;
  GotLine: Boolean;
  ResultMsg: string;
begin
  // NOTE: no initial "Result := True" here - both exit paths below
  // (ESC -> False, "0" -> True) always set Result immediately before
  // Exit, so a default assignment here was dead code (DCC H2077).

  // Header/menu is printed once on entry, not repeated after every choice.
  WriteBlankLine;
  WriteConsoleLine(SETTINGS_HEADER_STR);
  WriteConsoleLine(StringOfChar('-', Length(SETTINGS_HEADER_STR)));
  WriteConsoleLine(HELP_INSTALL_PREFIX_STR + ChangeFileExt(APP_PATH_NAME, '') + HELP_INSTALL_SUFFIX_STR);
  WriteConsoleLine(HELP_INSTALL_LINE2_STR);
  WriteConsoleLine(HELP_UNINSTALL_LINE_STR);
  WriteConsoleLine(HELP_ABOUT_LINE_STR);
  WriteBlankLine;
  WriteConsoleLine(HELP_HOME_LINE_STR);
  WriteBlankLine;

  while True do
  begin
    WriteConsoleText(CHOICE_PROMPT_STR);
    GotLine := ReadLineEsc(Choice);
    if not GotLine then
    begin
      Result := False;
      Exit;
    end;

    Choice := Trim(Choice);

    if Choice = '0' then
    begin
      Result := True;
      Exit;
    end
    else if SameText(Choice, '-install') then
    begin
      if InstallAppPathsEntry then
        ResultMsg := INSTALL_SUCCESS_PREFIX_STR + ChangeFileExt(APP_PATH_NAME, '') + INSTALL_SUCCESS_SUFFIX_STR
      else
        ResultMsg := INSTALL_FAIL_STR;
    end
    else if SameText(Choice, '-uninstall') then
    begin
      if UninstallAppPathsEntry then
        ResultMsg := UNINSTALL_SUCCESS_STR
      else
        ResultMsg := UNINSTALL_NOOP_STR;
    end
    else if SameText(Choice, '-about') then
    begin
      ShowAboutBlock;
      ResultMsg := ''; // ShowAboutBlock already prints its own separators/blank line
    end
    else if Choice <> '' then
      ResultMsg := UNRECOGNIZED_OPTION_STR + Choice
    else
      ResultMsg := '';

    // After each processed choice, print only the result and a separator
    // line matching its width - not the whole menu again.
    if ResultMsg <> '' then
    begin
      WriteConsoleLine(ResultMsg);
      WriteConsoleLine(StringOfChar('-', Length(ResultMsg)));
      WriteBlankLine;
    end;
  end;
end;

// ---------------------------------------------------------------------
// The "Note: Type -help for settings or instructions." hint only needs
// to be shown once per run. The very first time PrintPathPrompt runs,
// it also prints "Path: " itself, remembers exactly where the cursor
// sits at that point (i.e. where the user is meant to type), prints the
// hint plus a dashed line underneath starting one row below that, then
// moves the cursor back up to the remembered spot - so the note is
// visible on screen but typing still happens right after "Path: ", not
// below the note.
//
// While the user is typing/pasting, EnsureHintPosition (declared above,
// wired in via ReadLineEsc's AfterCharProc) keeps pushing the hint block
// further down the moment console line-wrap would otherwise carry the
// typed text into it - so a long pasted path can never overwrite it.
//
// Returns True if it already printed "Path: " itself, so the caller's
// loop must skip printing it again for that one iteration.
//
// Once the user finishes typing and presses Enter, AdvancePastHintIfPending
// must be called: it moves the cursor down past the blank/note/dash lines
// (wherever they currently are, since EnsureHintPosition may have moved
// them) and adds one blank line, so everything printed afterwards (error
// messages, the next prompt, etc.) continues normally below the hint
// instead of overlapping and garbling it.
// ---------------------------------------------------------------------
function PrintPathPrompt: Boolean;
var
  InputPos: TCoord;
begin
  Result := False;
  WriteConsoleLine(ENTER_PATH_PROMPT_STR);

  if not HelpHintShown then
  begin
    WriteConsoleText(PATH_PROMPT_STR);
    InputPos := GetCursorPos;

    HelpHintTopRow := InputPos.Y + 1;
    WriteAtRow(HelpHintTopRow, '');
    WriteAtRow(HelpHintTopRow + 1, HELP_HINT_STR);
    WriteAtRow(HelpHintTopRow + 2, StringOfChar('-', Length(HELP_HINT_STR)));

    SetCursorPos(InputPos);
    HelpHintShown := True;
    HelpHintPending := True;
    Result := True;
  end;
end;

procedure AdvancePastHintIfPending;
var
  Pos: TCoord;
begin
  if not HelpHintPending then
    Exit;
  HelpHintPending := False;

  // HelpHintTopRow may have been pushed down by EnsureHintPosition while
  // the user was typing, so always read it fresh rather than assuming a
  // fixed offset from the original "Path: " row.
  Pos.X := 0;
  Pos.Y := HelpHintTopRow + 3;
  SetCursorPos(Pos);
  WriteBlankLine;
end;

// This function asks for project path - shows full message only when no project found
// Also accepts "-help" to open the settings/instructions screen, and
// "-install" / "-uninstall" / "-about" to run those actions directly
// from Clean Mode without going through the "-help" submenu.
// Returns '' and Halt(0)s the app if the user presses ESC anywhere.
function AskForProjectPath(const ShowNoProjectMessage: Boolean = True): string;
var
  InputPath: string;
  GotLine: Boolean;
  ErrMsg: string;
  ResultMsg: string;
  DefaultMsg: string;
  SkipPathPrompt: Boolean;
begin
  Result := '';

  if ShowNoProjectMessage then
  begin
    WriteBlankLine;
    WriteConsoleLine(NO_PROJECT_CURRENT_DIR_STR);
  end;

  SkipPathPrompt := PrintPathPrompt;

  repeat
    if SkipPathPrompt then
      SkipPathPrompt := False
    else
      WriteConsoleText(PATH_PROMPT_STR);
    GotLine := ReadLineEsc(InputPath, @EnsureHintPosition);

    if not GotLine then
    begin
      // User pressed ESC - exit immediately
      Halt(0);
    end;

    // If the hint block was drawn below this "Path: " line, move the
    // cursor past it now (before printing anything else) so the error
    // message / next prompt / etc. appear cleanly below it instead of
    // overlapping the Note/dash lines.
    AdvancePastHintIfPending;

    InputPath := Trim(InputPath);

    if SameText(InputPath, '-help') then
    begin
      if not ShowHelpMenu then
        Halt(0); // ESC pressed inside help menu
      DefaultMsg := DEFAULT_PAGE_STR;
      WriteConsoleLine(DefaultMsg);
      WriteConsoleLine(StringOfChar('-', Length(DefaultMsg)));
      WriteBlankLine;
      SkipPathPrompt := PrintPathPrompt;
      Continue;
    end
    else if SameText(InputPath, '-install') then
    begin
      if InstallAppPathsEntry then
        ResultMsg := INSTALL_SUCCESS_PREFIX_STR + ChangeFileExt(APP_PATH_NAME, '') + INSTALL_SUCCESS_SUFFIX_STR
      else
        ResultMsg := INSTALL_FAIL_STR;
      WriteConsoleLine(ResultMsg);
      WriteConsoleLine(StringOfChar('-', Length(ResultMsg)));
      WriteBlankLine;
      SkipPathPrompt := PrintPathPrompt;
      Continue;
    end
    else if SameText(InputPath, '-uninstall') then
    begin
      if UninstallAppPathsEntry then
        ResultMsg := UNINSTALL_SUCCESS_STR
      else
        ResultMsg := UNINSTALL_NOOP_STR;
      WriteConsoleLine(ResultMsg);
      WriteConsoleLine(StringOfChar('-', Length(ResultMsg)));
      WriteBlankLine;
      SkipPathPrompt := PrintPathPrompt;
      Continue;
    end
    else if SameText(InputPath, '-about') then
    begin
      ShowAboutBlock;
      SkipPathPrompt := PrintPathPrompt;
      Continue;
    end;

    InputPath := StripSurroundingQuotes(InputPath);
    InputPath := Trim(InputPath);

    if InputPath = '' then
      ErrMsg := PATH_EMPTY_STR
    else if not DirectoryExists(InputPath) then
      ErrMsg := INVALID_PATH_STR
    else
      ErrMsg := '';

    if ErrMsg <> '' then
    begin
      // Show just the error and a separator matching its width instead
      // of repeating the whole "Please enter the project path..." block.
      WriteConsoleLine(ErrMsg);
      WriteConsoleLine(StringOfChar('-', Length(ErrMsg)));
      WriteBlankLine;
      WriteConsoleLine(ENTER_PATH_PROMPT_STR);
      Continue;
    end;

    Result := InputPath;
    Break;
  until False;
end;

function FindProjectsInPath(const Path: string): Boolean;
begin
  BasePath := Path;
  if (Length(BasePath) > 0) and (BasePath[Length(BasePath)] = '\') then
    BasePath := Copy(BasePath, 1, Length(BasePath) - 1);

  DPRFiles.Clear;
  FindFilesRecursive(BasePath, '.dpr', DPRFiles);
  Result := DPRFiles.Count > 0;
end;

function IsFileInProjectFolder(const FilePath, ProjectFolder: string): Boolean;
begin
  Result := Pos(LowerCase(ProjectFolder), LowerCase(FilePath)) = 1;
end;

function GetRelativePath(const BaseFolder, FullPath: string): string;
begin
  Result := FullPath;
  if AnsiStartsText(BaseFolder, Result) then
  begin
    Result := Copy(Result, Length(BaseFolder) + 1, MaxInt);
    if (Length(Result) > 0) and (Result[1] = '\') then
      Result := Copy(Result, 2, MaxInt);
  end;
end;

procedure DeleteFilesAndFolders;
var
  DPRFile: string;
  BaseName: string;
  DisplayName: string;
  DPRFolder: string;
  ResFile, CfgFile: string;
  FoundFiles: TStringList;
  FoundFolders: TStringList;
  DeleteList: TStringList;
  AllBaseNames: TStringList;
  DisplayNames: TStringList;
  OtherItems: TStringList;
  ProjectItems: TStringList;
  i, j, k: Integer;
  Extensions: array of string;
  Ext: string;
  UserPath: string;
  ShownItemCount: Integer;
  ProjectFileMap: TStringList;
  ProjectFolderMap: TStringList;
  FilePath: string;
  ProjectIdx: Integer;
  RelativePath: string;
  CurrentDir: string;
  FirstRun: Boolean;
  ErrMsg: string;
begin
  DPRFiles := TStringList.Create;
  FoundFiles := TStringList.Create;
  FoundFolders := TStringList.Create;
  DeleteList := TStringList.Create;
  OtherItems := TStringList.Create;
  DisplayNames := TStringList.Create;
  AllBaseNames := TStringList.Create;
  ProjectFileMap := TStringList.Create;
  ProjectFolderMap := TStringList.Create;

  try
    FirstRun := True;

    while True do
    begin
      // First, try to find projects in the current directory and all subdirectories
      if FirstRun then
      begin
        // The app is launched with the current folder as the working directory
        // whenever the "dpclean" address-bar shortcut is used, and that is also
        // equal to the exe's own folder when double-clicked normally.
        CurrentDir := GetCurrentDir;

        if (Length(CurrentDir) > 0) and (CurrentDir[Length(CurrentDir)] = '\') then
          CurrentDir := Copy(CurrentDir, 1, Length(CurrentDir) - 1);

        BasePath := CurrentDir;
        DPRFiles.Clear;
        ProgressUpdate(SCAN_PROJECTS_STR, 0);
        FindFilesRecursive(BasePath, '.dpr', DPRFiles);
        ProgressClear;

        // If no projects found in the current directory, go straight to the
        // path prompt without the "No Delphi project found in the current
        // directory." message - that message is not needed here. It still
        // shows correctly below (NO_PROJECT_SPECIFIED_PATH_STR) whenever the
        // user manually types a path that has no project in it.
        if DPRFiles.Count = 0 then
        begin
          while True do
          begin
            UserPath := AskForProjectPath(False);
            if UserPath = '' then
              Exit;

            // Search for projects in user-specified path
            ProgressUpdate(SCAN_PROJECTS_STR, 0);
            if FindProjectsInPath(UserPath) then
            begin
              ProgressClear;
              BasePath := UserPath;
              Break;
            end
            else
            begin
              ProgressClear;
              ErrMsg := NO_PROJECT_SPECIFIED_PATH_STR + UserPath;
              WriteConsoleLine(ErrMsg);
              WriteConsoleLine(StringOfChar('-', Length(ErrMsg)));
              WriteBlankLine;
              // Continue loop to ask again
            end;
          end;
        end;

        FirstRun := False;
      end;

      // Now we have projects in DPRFiles and BasePath is set
      WriteBlankLine;
      WriteConsoleLine(CURRENT_PATH_STR + BasePath);
      WriteBlankLine;

      WriteConsoleLine(PROJECTS_LIST_HEADER_STR);
      WriteConsoleLine(StringOfChar('-', Length(PROJECTS_LIST_HEADER_STR)));
      for i := 0 to DPRFiles.Count - 1 do
        WriteConsoleLine('  ' + ChangeFileExt(ExtractFileName(DPRFiles[i]), ''));
      WriteBlankLine;
      WriteBlankLine;

      SetLength(Extensions, 11);
      Extensions[0] := '.dres';
      Extensions[1] := '.identcache';
      Extensions[2] := '.tvsconfig';
      Extensions[3] := '.~dpr';
      Extensions[4] := '.dof';
      Extensions[5] := '.bdsproj.local';
      Extensions[6] := '.dcu';
      Extensions[7] := '.stat';
      Extensions[8] := '.otares';
      Extensions[9] := '.vlb';
      Extensions[0] := '.rsm';


      // Clear previous lists before building new ones
      AllBaseNames.Clear;
      DisplayNames.Clear;
      DeleteList.Clear;
      OtherItems.Clear;
      ProjectFileMap.Clear;
      ProjectFolderMap.Clear;

      for i := 0 to DPRFiles.Count - 1 do
        AllBaseNames.Add(ChangeFileExt(ExtractFileName(DPRFiles[i]), ''));

      ProgressUpdate(SCAN_PROJECT_FOLDERS_STR, 0);
      for i := 0 to DPRFiles.Count - 1 do
      begin
        ProgressUpdate(SCAN_PROJECT_FOLDERS_STR, Round(((i + 1) / Max(1, DPRFiles.Count)) * 50));

        DPRFile := DPRFiles[i];
        DPRFolder := ExtractFilePath(DPRFile);
        BaseName := ChangeFileExt(ExtractFileName(DPRFile), '');

        if CountNameOccurrences(AllBaseNames, BaseName) > 1 then
          DisplayName := RelativeToBase(DPRFile)
        else
          DisplayName := BaseName + '.dpr';
        DisplayNames.Add(DisplayName);

        // Store project folder for mapping
        ProjectFolderMap.Add(DPRFolder);

        // .res file - same folder as this project's .dpr
        ResFile := JoinPath(DPRFolder, BaseName + '.res');
        if FileExists(ResFile) then
        begin
          DeleteList.Add(ResFile);
          ProjectFileMap.Add(IntToStr(i) + '|' + ResFile);
        end;

        // .cfg file - same folder as this project's .dpr
        CfgFile := JoinPath(DPRFolder, BaseName + '.cfg');
        if FileExists(CfgFile) then
        begin
          DeleteList.Add(CfgFile);
          ProjectFileMap.Add(IntToStr(i) + '|' + CfgFile);
        end;

        FoundFolders.Clear;
        FindFoldersRecursive(DPRFolder, 'ModelSupport_' + BaseName, FoundFolders, False);
        for j := 0 to FoundFolders.Count - 1 do
        begin
          if DeleteList.IndexOf(FoundFolders[j]) = -1 then
          begin
            DeleteList.Add(FoundFolders[j]);
            ProjectFileMap.Add(IntToStr(i) + '|' + FoundFolders[j]);
          end;
        end;

        FoundFiles.Clear;
        FindDprojVariantFiles(DPRFolder, BaseName, FoundFiles);
        for j := 0 to FoundFiles.Count - 1 do
        begin
          if DeleteList.IndexOf(FoundFiles[j]) = -1 then
          begin
            DeleteList.Add(FoundFiles[j]);
            ProjectFileMap.Add(IntToStr(i) + '|' + FoundFiles[j]);
          end;
        end;

        for k := 0 to High(Extensions) do
        begin
          Ext := Extensions[k];
          FoundFiles.Clear;
          FindFilesRecursive(DPRFolder, BaseName + Ext, FoundFiles);
          for j := 0 to FoundFiles.Count - 1 do
          begin
            if DeleteList.IndexOf(FoundFiles[j]) = -1 then
            begin
              DeleteList.Add(FoundFiles[j]);
              ProjectFileMap.Add(IntToStr(i) + '|' + FoundFiles[j]);
            end;
          end;
        end;
      end;

      // Find global items (not specific to any project)
      ProgressUpdate(SCAN_LEFTOVER_FILES_STR, 55);
      FoundFolders.Clear;
      FindFoldersRecursive(BasePath, 'ModelSupport_', FoundFolders, True);
      for j := 0 to FoundFolders.Count - 1 do
      begin
        if DeleteList.IndexOf(FoundFolders[j]) = -1 then
          DeleteList.Add(FoundFolders[j]);
      end;

      for k := 0 to High(Extensions) do
      begin
        ProgressUpdate(SCAN_LEFTOVER_FILES_STR, 55 + Round(((k + 1) / Length(Extensions)) * 30));
        Ext := Extensions[k];
        FoundFiles.Clear;
        FindFilesRecursive(BasePath, Ext, FoundFiles);
        for j := 0 to FoundFiles.Count - 1 do
        begin
          if DeleteList.IndexOf(FoundFiles[j]) = -1 then
          begin
            DeleteList.Add(FoundFiles[j]);
            // Check if this file belongs to any project
            FilePath := FoundFiles[j];
            ProjectIdx := -1;
            for i := 0 to ProjectFolderMap.Count - 1 do
            begin
              if IsFileInProjectFolder(FilePath, ProjectFolderMap[i]) then
              begin
                ProjectIdx := i;
                Break;
              end;
            end;
            if ProjectIdx >= 0 then
              ProjectFileMap.Add(IntToStr(ProjectIdx) + '|' + FilePath)
            else
              OtherItems.Add(RelativeToBase(FilePath));
          end;
        end;
      end;

      ProgressUpdate(SCAN_ORPHANED_FILES_STR, 88);
      FoundFiles.Clear;
      FindOrphanVariantFiles(BasePath, FoundFiles);
      for j := 0 to FoundFiles.Count - 1 do
      begin
        if DeleteList.IndexOf(FoundFiles[j]) = -1 then
        begin
          DeleteList.Add(FoundFiles[j]);
          OtherItems.Add(RelativeToBase(FoundFiles[j]));
        end;
      end;

      ProgressUpdate(SCAN_HISTORY_FOLDERS_STR, 94);
      FoundFolders.Clear;
      FindFoldersRecursive(BasePath, '__history', FoundFolders);
      for j := 0 to FoundFolders.Count - 1 do
      begin
        if DeleteList.IndexOf(FoundFolders[j]) = -1 then
        begin
          DeleteList.Add(FoundFolders[j]);
          OtherItems.Add(RelativeToBase(FoundFolders[j]));
        end;
      end;

      FoundFolders.Clear;
      FindFoldersRecursive(BasePath, '__recovery', FoundFolders);
      for j := 0 to FoundFolders.Count - 1 do
      begin
        if DeleteList.IndexOf(FoundFolders[j]) = -1 then
        begin
          DeleteList.Add(FoundFolders[j]);
          OtherItems.Add(RelativeToBase(FoundFolders[j]));
        end;
      end;

      ProgressUpdate(SCAN_COMPLETE_STR, 100);
      ProgressClear;

      // NOTE: previously tracked a "CleanedCount" (successful deletions)
      // here that was never read anywhere - removed to clear the DCC
      // H2077 dead-store hints. The final summary below already derives
      // its count from ProjectFileMap/OtherItems (items actually
      // itemized/displayed), so nothing downstream depended on it.
      for i := 0 to DeleteList.Count - 1 do
      begin
        ProgressUpdate(DELETING_FILES_STR, Round(((i + 1) / Max(1, DeleteList.Count)) * 100));
        try
          if DirectoryExists(DeleteList[i]) then
          begin
            DeleteFolderRecursive(DeleteList[i]);
          end
          else if FileExists(DeleteList[i]) then
          begin
            DeleteFile(DeleteList[i]);
          end;
        except
          on E: Exception do
          begin
            ProgressClear;
            WriteConsoleLine(ERROR_DELETING_PREFIX_STR + DeleteList[i] + ERROR_DELETING_SEP_STR + E.Message);
          end;
        end;
      end;
      ProgressClear;

      // Delete empty folders left behind (not counted towards the summary:
      // these are incidental leftovers, not files/folders the cleaner
      // specifically targeted, so they must not affect the summary below).
      ProgressUpdate(REMOVING_EMPTY_FOLDERS_STR, 0);
      DeleteEmptyFolders(BasePath);
      ProgressClear;

      // ---- Final summary ----
      // Only count items that are actually itemized/displayed below
      // (per-project files/folders + "Other Files"). This avoids showing
      // an empty "Deleted File List" when the only things removed were
      // untracked leftover folders.
      ShownItemCount := ProjectFileMap.Count + OtherItems.Count;

      if ShownItemCount = 0 then
      begin
        WriteBlankLine;
        WriteConsoleLine(ALREADY_CLEANED_STR);
        WriteConsoleLine(StringOfChar('-', Length(ALREADY_CLEANED_STR)));
        WriteBlankLine;

        // Now ask for new path - but WITHOUT the "No Delphi project found" message
        // because project WAS found
        while True do
        begin
          UserPath := AskForProjectPath(False); // Don't show "No Delphi project found..." message
          if UserPath = '' then
            Exit;

          ProgressUpdate(SCAN_PROJECTS_STR, 0);
          if FindProjectsInPath(UserPath) then
          begin
            ProgressClear;
            BasePath := UserPath;
            // Break out of inner loop and continue with new path
            Break;
          end
          else
          begin
            ProgressClear;
            ErrMsg := NO_PROJECT_SPECIFIED_PATH_STR + UserPath;
            WriteConsoleLine(ErrMsg);
            WriteConsoleLine(StringOfChar('-', Length(ErrMsg)));
            WriteBlankLine;
            // Continue loop to ask again
          end;
        end;
        // Continue to next iteration of outer loop with new path
        Continue;
      end
      else
      begin
        WriteBlankLine;
        WriteConsoleLine(DELETED_LIST_HEADER_STR);
        WriteConsoleLine(StringOfChar('-', Length(DELETED_LIST_HEADER_STR)));

        // Display files grouped by project
        for i := 0 to DPRFiles.Count - 1 do
        begin
          ProjectItems := TStringList.Create;
          try
            // Find all files for this project from ProjectFileMap
            for j := 0 to ProjectFileMap.Count - 1 do
            begin
              if Pos(IntToStr(i) + '|', ProjectFileMap[j]) = 1 then
              begin
                FilePath := Copy(ProjectFileMap[j], Pos('|', ProjectFileMap[j]) + 1, MaxInt);
                // Get relative path from project folder
                RelativePath := GetRelativePath(ProjectFolderMap[i], FilePath);
                if RelativePath <> '' then
                  ProjectItems.Add(RelativePath);
              end;
            end;

            if ProjectItems.Count > 0 then
            begin
              // Sort items for better display
              ProjectItems.Sort;
              WriteConsoleLine('  ' + DisplayNames[i]);
              for j := 0 to ProjectItems.Count - 1 do
                WriteConsoleLine('        ' + BULLET + ' ' + ProjectItems[j]);
              WriteBlankLine;
            end;
          finally
            ProjectItems.Free;
          end;
        end;

        // Show "Press any key" ONLY when files were actually cleaned
        WriteConsoleLine(PRESS_ANY_KEY_STR);
        PressAnyKeyToExit;
        Halt(0); // Exit the program completely
      end;
    end;

  finally
    DPRFiles.Free;
    FoundFiles.Free;
    FoundFolders.Free;
    DeleteList.Free;
    OtherItems.Free;
    DisplayNames.Free;
    AllBaseNames.Free;
    ProjectFileMap.Free;
    ProjectFolderMap.Free;
  end;
end;


begin
  ShowConsole;

  // Command-line argument handling
  if ParamCount > 0 then
  begin
    if SameText(ParamStr(1), '-install') then
    begin
      if InstallAppPathsEntry then
      begin
      WriteBlankLine;
      WriteConsoleLine(INSTALL_SUCCESS_PREFIX_STR + ChangeFileExt(APP_PATH_NAME, '') + INSTALL_SUCCESS_SUFFIX_STR)
      end else
      WriteConsoleLine(INSTALL_FAIL_STR);
      PressAnyKeyToExit;
      Halt(0);
    end
    else if SameText(ParamStr(1), '-uninstall') then
    begin
      if UninstallAppPathsEntry then
      begin
      WriteBlankLine;
      WriteConsoleLine(UNINSTALL_SUCCESS_STR)
      end
      else
      WriteConsoleLine(UNINSTALL_NOOP_STR);
      PressAnyKeyToExit;
      Halt(0);
    end
    else if SameText(ParamStr(1), '-help') then
    begin
      ShowHelpMenu;
      Halt(0);
    end
    else if SameText(ParamStr(1), '-about') then
    begin
      WriteBlankLine;
      ShowAboutBlock;
      PressAnyKeyToExit;
      Halt(0);
    end;
  end;
  try
    DeleteFilesAndFolders;
  except
  end;



end.