Skip to content

Releases

v0.2.0 - rule execution, manual run, first-run setup

Choose a tag to compare

@harshit51290 harshit51290 released this 04 Oct 11:30

Every alert-rule change is applied automatically now, not just on daemon restart.

What this adds

Manual run. Every rule now has a Run button. It opens on a preview showing exactly which files match and where each one would go, so nothing moves before you have read the list.

Rules actually execute. There was no matcher or executor in the tree before this. Move, Copy, Rename and Sort by folder all work. Recycle Bin and Run command refuse with an explanation rather than doing something irreversible.

First-run setup. Previously first launch meant typing a rule name, browsing for folders, typing extensions, and typing an absolute destination path. Setup now detects your Downloads, Desktop, Pictures and Documents folders, pre-fills valid rules for them, and leaves every rule switched off with dry-run on. Every control is a deselection, not a construction.

Update check. The app tells you when a newer release exists and links to it. It does not download or replace anything on its own.

Fixes found along the way

  • The config watcher never reloaded: the debounce timer had due-time and period swapped.
  • Saving reported success even when the save was refused for containing errors.
  • The search filter did nothing; row visibility was never bound.
  • The notifications master switch was not wired, so its handler was unreachable.
  • Validation errors were being written into rules.json.
  • pack.ps1 never stamped the version onto the assembly, so every build reported 1.0.0.

Known gaps

  • Recycle Bin needs shell integration; it refuses for now rather than falling back to a permanent delete.
  • Run command has no allowlist yet; it refuses.
  • No self-updating installer. Running the new release over an old install replaces the app and keeps your rules, which live in %LOCALAPPDATA%.

v0.1.1 - fixes the crash when adding a rule

Choose a tag to compare

@harshit51290 harshit51290 released this 04 Oct 00:51

[Unreleased]

Nothing yet.

[0.1.1] - Unreleased

Bug-fix release. The 0.1.0 editor crashed when adding a rule, so upgrade before
relying on it.

Fixed

  • Adding a rule crashed the app. Two independent causes:
    1. RuleEditorWindow and DiagnosticsWindow resolved their controls in
      OnInitialized. For a Window, Avalonia raises that from inside the base
      constructor, which in C# runs before the derived constructor body, so
      InitializeComponent() had not yet run and the logical tree was empty. Every
      lookup threw No TextBlock named 'HeaderTitle' found. Moved to OnOpened,
      which is the first point at which the XAML is guaranteed loaded.
    2. RulesView.ApplyFilter replaced ItemsControl.ItemsSource wholesale on every
      refresh. Adding a rule reassigns it, which tore down every item container
      mid-frame and Avalonia's ContentPresenter null-referenced. The list now binds
      its source once and filters by toggling row visibility. RuleRow also honours
      the in-place design its own documentation described, and raises change
      notifications, so the enabled toggle no longer loses state across a reload.
  • Subfolder recursion defaulted to on. A rule pointed at a folder silently
    claimed files nested arbitrarily deep beneath it. Now opt-in per rule, with a
    clearer label and a hint saying what the toggle actually does.
  • Autostart always reported as unregistered. The installer writes the Run value
    as "File Juggler" while the diagnostics report queried "FileJuggler". The
    mismatch was silent, so a user could not tell whether autostart was working.
    Locked by a contract test that reads the installer script.
  • Registry access in the diagnostics report is guarded by
    OperatingSystem.IsWindows() rather than relying on a caught exception.

Changed

  • The configuration serializer now uses the source-generated AppConfigJsonContext.
    That context already existed but was dead code: ConfigStore still called the
    reflection-based overloads, which are RequiresUnreferencedCode and
    RequiresDynamicCode and cannot survive NativeAOT. Its UseStringEnumConverter
    was never enabled, which is very likely how enums came to be written as integers
    in the first place. GenerationMode moved from Metadata to Default, because
    Metadata emits type metadata only and cannot serialize.
  • Build warnings reduced from 10 to 2. The remaining two are Avalonia noting that the
    two windows have no public parameterless constructor, which is expected for windows
    that take constructor arguments.
  • Added tools/uismoke.ps1, which drives the real UI through UI Automation and fails
    on a crash or a fresh stack trace. Both crashes above were invisible to the build
    and to the existing tests; they only appeared once the app was actually clicked.

Known issues

  • Right-hand controls can clip. On a 125% display the window frame is created
    smaller than Avalonia lays out, so trailing controls in the header, toolbars and
    rule rows render past the window edge. DPI awareness is verified correct
    (per-monitor v2, manifest embedded in both configurations), which rules out the
    obvious cause. Explicitly resizing the window makes it render correctly, so the
    frame does respond to size changes; only the initial size is wrong. Unresolved.

v0.1.0 - pre-alpha: rule engine, config, rule editor

Choose a tag to compare

@harshit51290 harshit51290 released this 03 Oct 23:08

Pre-alpha. The rule engine, configuration layer and rule editor work and are
tested. The resident daemon does not exist yet, so no rule has ever been
applied to a file on disk.
There is currently no code path that moves,
copies or deletes anything.

First public release. The point of publishing now is to get the design reviewed
before the part that touches real files gets written.

Download

FileJuggler-0.1.0-win-x64.zip (~43 MB) is attached below. One self-contained
executable: no compiler, no SDK, no .NET runtime install required.

Extract it and run Juggler.Ui.exe. Config is created on first launch at
%LOCALAPPDATA%\FileJuggler\rules.json.

Self-contained rather than NativeAOT. NativeAOT would give a far smaller, faster
binary and is what the resident daemon will eventually use, but it requires the
Visual Studio C++ build tools and Windows SDK and fails without them. The editor
is an on-demand process, so its size is not what is being optimised.

What works

  • Rule engine. A rule is a monitor (folders to watch), an If (conditions that
    must all match), and a Then. Conditions: extension, name glob, name regex, size
    range, created/modified date range. Actions: move, copy, rename, sort into
    subfolders by extension/name/date/size, delete to Recycle Bin, run a command
    from an allowlist.
  • Config layer. Atomic temp-and-rename writes, full validation before
    anything is persisted, hot reload through a file watcher, undo-journal path.
  • Rule editor. Avalonia, launched on demand and holding no memory at idle.
    Rules list, rule editor, activity log, settings, diagnostics report.
  • 22 tests over the validator, the config store round trip, and the safety
    guards below.

Two data-loss bugs found and fixed

Both silently overwrote a real configuration with an empty "rules": [].

  1. Enum serialization. The serializer wrote enums as integers ("mode": 0)
    while the shipped config/example.rules.json used names
    ("mode": "Resident"). Loading the example threw, the load was reported as
    failed, the in-memory config stayed at its empty default, and the next
    settings save wrote that default back over the user's rules.

  2. Atomic save looked like deletion. File.Move with overwrite briefly
    leaves the config path unresolvable. The file watcher fired inside that window,
    Load() reported the missing file as empty defaults with no error, and
    those defaults were adopted and persisted.

Both are now regression tests. Save() refuses to write when the last load
failed, and only a genuinely parsed file is treated as authoritative. A config
that cannot be read is never overwritten.

Also fixed

  • Theme resources resolved against the wrong palette on startup, because
    RequestedThemeVariant was set in Window.Opened rather than before the first
    window was realized. A dark window rendered one control in the light palette.
  • The watcher used a leading-edge throttle, so its first event landed inside
    exactly the window it needed to avoid. Replaced with a trailing-edge debounce.
  • Mojibake throughout the UI strings and the published documentation.

Known issue

On a 125% DPI display the window frame is created smaller than Avalonia lays out,
so trailing controls in the header, toolbars and rule rows can render past the
window edge. Under investigation.

Next

The resident daemon: tray, ReadDirectoryChangesW with a bounded channel,
executor, undo journal, reconciler. Then the budget harness that turns the memory
targets in the README into CI-enforced limits.

Build from source

Requires the .NET 10 SDK.

dotnet build Juggler.slnx
dotnet test  Juggler.slnx
dotnet run --project src/Juggler.Ui
.\tools\pack.ps1          # produces the downloadable zip

Licence

MIT.