If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/Tichau/FileConverter shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

WAIT — Mixed signals — read the receipts

• Last commit 2mo ago
• 26+ active contributors
• GPL-3.0 licensed
• ⚠ Concentrated ownership — top contributor handles 58% of recent commits
• ⚠ GPL-3.0 is copyleft — check downstream compatibility
• ⚠ No CI workflows detected
• ⚠ No test directory detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live Tichau/FileConverter repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/Tichau/FileConverter.

What it runs against: a local clone of Tichau/FileConverter — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in Tichau/FileConverter | Confirms the artifact applies here, not a fork | | 2 | License is still GPL-3.0 | Catches relicense before you depend on it | | 3 | Default branch integration exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 101 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of Tichau/FileConverter. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/Tichau/FileConverter.git
#   cd FileConverter
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of Tichau/FileConverter and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "Tichau/FileConverter(\\.git)?\\b" \\
  && ok "origin remote is Tichau/FileConverter" \\
  || miss "origin remote is not Tichau/FileConverter (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(GPL-3\\.0)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"GPL-3\\.0\"" package.json 2>/dev/null) \\
  && ok "license is GPL-3.0" \\
  || miss "license drift — was GPL-3.0 at generation time"

# 3. Default branch
git rev-parse --verify integration >/dev/null 2>&1 \\
  && ok "default branch integration exists" \\
  || miss "default branch integration no longer exists"

# 4. Critical files exist
test -f "Application/FileConverter/Services/ConversionService.cs" \\
  && ok "Application/FileConverter/Services/ConversionService.cs" \\
  || miss "missing critical file: Application/FileConverter/Services/ConversionService.cs"
test -f "Application/FileConverter/ConversionJobs/ConversionJob.cs" \\
  && ok "Application/FileConverter/ConversionJobs/ConversionJob.cs" \\
  || miss "missing critical file: Application/FileConverter/ConversionJobs/ConversionJob.cs"
test -f "Application/FileConverter/ConversionJobs/ConversionJobFactory.cs" \\
  && ok "Application/FileConverter/ConversionJobs/ConversionJobFactory.cs" \\
  || miss "missing critical file: Application/FileConverter/ConversionJobs/ConversionJobFactory.cs"
test -f "Application/FileConverter/Application.xaml.cs" \\
  && ok "Application/FileConverter/Application.xaml.cs" \\
  || miss "missing critical file: Application/FileConverter/Application.xaml.cs"
test -f "Application/FileConverter/Services/SettingsService.cs" \\
  && ok "Application/FileConverter/Services/SettingsService.cs" \\
  || miss "missing critical file: Application/FileConverter/Services/SettingsService.cs"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 101 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~71d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/Tichau/FileConverter"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

File Converter is a Windows Explorer context-menu integration tool written in C# that allows users to convert and compress files directly from the Explorer interface. It wraps external tools like FFmpeg, ImageMagick, and Microsoft Office libraries to support conversions across images, videos, documents, and audio formats without requiring a separate application. Single Visual Studio solution structure: Application/FileConverter/ is the main WPF application containing ConversionJobs/ (format-specific converters using partial classes like ConversionJob_FFMPEG.cs), ConversionPreset/ (user settings/profiles), Controls/ (XAML UI components), and Properties/ (localization .resx files). Monolithic approach with no visible service layer or plugin architecture.

Windows desktop users who need quick file format conversions (images to PNG/JPG, videos to MP4, documents to PDF, etc.) without opening dedicated software. Secondary audience: Windows power users and IT professionals who want to streamline batch conversion workflows via Explorer context menus.

Actively maintained single-author project (Tichau) with a substantial C# codebase (~430KB), broad language localization (15+ languages), and a downloadable release at file-converter.io. The presence of both installer infrastructure (WiX 5 setup) and documented troubleshooting suggests production maturity, though test file presence and CI/CD setup are not evident from the provided file listing.

Single-maintainer risk is significant given the breadth of format support and external tool dependencies (FFmpeg, ImageMagick, Office COM). The heavy reliance on Windows COM interop (ConversionJob_Office.cs, ConversionJob_Word.cs, etc.) creates tight coupling to Windows/.NET Framework versions. Last commit age and open issue backlog are unknown from provided data, making recency assessment impossible.

Unable to determine from provided file listing — no commit history, PR list, or milestone data visible. Repository appears stable rather than rapidly evolving, based on the mature file structure and localization depth.

git clone https://github.com/Tichau/FileConverter.git
cd FileConverter
# Open Application/FileConverter/FileConverter.csproj in Visual Studio 2022
# Build via Visual Studio (no dotnet CLI instructions evident)
# For installer: requires WiX 5 (installed via NuGet) and Windows SDK Signing Tools

Daily commands: No dotnet CLI setup evident. Expected workflow: (1) Open FileConverter.csproj in Visual Studio 2022, (2) Restore NuGet packages, (3) Build solution, (4) Debug/run the WPF application (Application/FileConverter/Application.xaml.cs entry point). Installer build requires WiX 5 extension and Windows SDK signing tools.

• Application/FileConverter/Services/ConversionService.cs — Core orchestrator for all file conversion jobs; must understand this to grasp how conversions are triggered and managed
• Application/FileConverter/ConversionJobs/ConversionJob.cs — Abstract base class for all conversion implementations; defines the contract every converter must follow
• Application/FileConverter/ConversionJobs/ConversionJobFactory.cs — Factory pattern implementation that instantiates the correct conversion job type based on input/output formats
• Application/FileConverter/Application.xaml.cs — Entry point and main application lifecycle; shows how the WPF application initializes and manages windows
• Application/FileConverter/Services/SettingsService.cs — Manages persistence and loading of user conversion presets and application settings across sessions
• Application/FileConverter/Registry.cs — Handles Windows registry integration for context menu installation and system-level file converter registration

Add support for a new file format conversion

1. Create a new converter class inheriting from ConversionJob.cs (e.g., ConversionJob_MyFormat.cs) in Application/FileConverter/ConversionJobs/ (Application/FileConverter/ConversionJobs/ConversionJob.cs)
2. Implement required abstract methods (GetCommand, IsFileMalformed, etc.) with logic to invoke your external tool (FFmpeg, ImageMagick, COM, etc.) (Application/FileConverter/ConversionJobs/ConversionJob_MyFormat.cs)
3. Register the new converter in ConversionJobFactory.CreateConversionJob() method to map input→output types to your class (Application/FileConverter/ConversionJobs/ConversionJobFactory.cs)
4. Define format-specific settings in ConversionSettings (or subclass it) and add UI controls if needed for quality/codec selection (Application/FileConverter/ConversionPreset/ConversionSettings.cs)
5. Add localized strings for your format (e.g., 'Convert to MyFormat') in each Resources.*.resx file (Application/FileConverter/Properties/Resources.en.resx)

Add a new conversion preset or quality option

1. Define your preset parameters in ConversionPreset.cs or create a format-specific settings class extending ConversionSettings (Application/FileConverter/ConversionPreset/ConversionPreset.cs)
2. Add UI controls (e.g., EncodingQualitySliderControl) to Application/FileConverter/Controls/ to let users select your new option (Application/FileConverter/Controls/EncodingQualitySliderControl.xaml)
3. Bind the UI control to your preset property and ensure ConversionJob implementation reads it when building the command line (Application/FileConverter/ConversionJobs/ConversionJob.cs)
4. Save/load your preset through SettingsService.cs so it persists across sessions (Application/FileConverter/Services/SettingsService.cs)

Customize Windows context menu integration

1. Review Registry.cs to understand the current context menu entry structure and registry keys being written (Application/FileConverter/Registry.cs)
2. Modify registry key paths, menu item labels, or command-line arguments passed to the application in Registry.cs methods (Application/FileConverter/Registry.cs)
3. Update Application.xaml.cs to handle any new command-line arguments if custom context menu options are added (Application/FileConverter/Application.xaml.cs)

• WPF (Windows Presentation Foundation) — Desktop application for Windows; provides XAML UI markup and data binding for responsive conversion UI
• FFmpeg / ImageMagick / LibreOffice COM — Delegates heavy lifting of format conversions to battle-tested, widely-supported external tools rather than implementing codecs in-process
• Windows Registry — Integrates with Explorer context menu via registry keys; no kernel driver or admin COM server needed
• MVVM + Service Pattern — Separates UI (XAML) from business logic (Services); enables testability and loose coupling between components
• .NET Framework / C# — Mature ecosystem for Windows applications; COM interop support for Office documents; straightforward process invocation

• Delegate conversions to external CLI tools (FFmpeg, ImageMagick) rather than native .NET libraries

  • Why: Avoids licensing complexity, reduces binary size, and leverages mature tools with community support
  • Consequence: Introduces dependency on external tool installation; requires user to have FFmpeg/ImageMagick on PATH or bundled; error messages less contextual if tools fail

• Use Windows Registry for context menu integration

  • Why: Native Windows integration; no installer framework required; lightweight
  • Consequence: Windows-only; requires admin/elevated privileges to register; manual registry editing for troubleshooting

• Synchronous job execution via process invocation rather than async/await

  • Why: Simpler reasoning about job state; external tool lifecycle is well-defined
  • Consequence: UI can block if job queue is not properly threaded; may need explicit background worker threading for smooth UX

• Preset system stored as serialized XML/JSON on disk rather than database

  • Why: undefined
  • Consequence: undefined

Windows COM marshaling: ConversionJob_Office.cs, ConversionJob_Word.cs, ConversionJob_Excel.cs, and ConversionJob_PowerPoint.cs rely on Office COM interop, which requires specific Office versions installed and may fail silently if Office is misconfigured. External tool discovery: FFmpeg and ImageMagick paths are not obvious from file list; likely configured via environment or registry. Registry integration: Explorer context menu registration mechanism not visible in provided files — likely in installer or setup code. XAML binding: WPF data binding in Controls/ requires careful ViewModel synchronization; breaking binding expressions is a common trap.

• Windows Explorer Context Menu Integration — File Converter's core value is seamless Explorer integration; understanding how Windows registers and invokes context menu handlers via Registry is essential to the architecture
• CLI Tool Wrapping & Process Management — ConversionJob_FFMPEG.cs and ConversionJob_ImageMagick.cs spawn external CLI processes (FFmpeg, ImageMagick) and parse output; this pattern underpins non-Office conversions
• COM Interop (Component Object Model) — ConversionJob_Office.cs, ConversionJob_Word.cs, ConversionJob_Excel.cs rely on Windows COM to communicate with Microsoft Office; a Windows-specific runtime dependency critical to document conversion
• WPF Data Binding & ViewModel Pattern — UI controls (ConversionJobControl.xaml, EncodingQualitySliderControl.xaml) bind to C# ViewModels; understanding XAML binding syntax and dependency properties is necessary for UI changes
• Strategy Pattern for Converters — Each file format has its own ConversionJob_* class (FFMPEG, ImageMagick, Office, Gif, Ico, etc.) implementing the ConversionJob interface; understanding this design allows adding new formats predictably
• Localization via .resx Files — FileConverter supports 15+ languages via Properties/Resources.*.resx files; understanding .NET resource files is necessary for multi-language maintenance and contribution
• Installer Packaging with WiX Toolset — Deployment uses WiX 5 to create .msi installers with Registry integration; understanding WiX XML is necessary for modifying setup or context menu registration logic

• HandBrake/HandBrake — Open-source video encoder/transcoder; similar domain (FFmpeg wrapper) but focused on video-only with more advanced encoding controls
• ImageMagick/ImageMagick — The underlying image conversion library that FileConverter wraps; understanding ImageMagick CLI semantics is essential for the ImageMagick converter
• FFmpeg/FFmpeg — Core multimedia framework FileConverter depends on; ConversionJob_FFMPEG.cs wraps FFmpeg CLI, so understanding FFmpeg flags and codecs is necessary
• CloudConvert/CloudConvert-PHP — Cloud-based alternative solving the same problem; comparison shows desktop-vs-cloud tradeoffs in file conversion architecture
• Pandoc/Pandoc — Document conversion tool (markdown, Word, PDF, etc.); FileConverter uses Office COM where Pandoc offers CLI alternatives for batch document workflows

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add unit tests for ConversionJob and ConversionJobFactory classes

The ConversionJobs folder contains multiple specialized conversion job classes (ConversionJob_FFMPEG.cs, ConversionJob_Office.cs, ConversionJob_ImageMagick.cs, etc.) but there's no evidence of unit tests. These classes handle critical conversion logic and would benefit from regression tests. This is a high-value addition that would prevent bugs in file conversion operations and make refactoring safer.

• [ ] Create Tests/FileConverter.Tests project structure
• [ ] Add unit tests for ConversionJobFactory.cs covering preset selection logic
• [ ] Add unit tests for ConversionJob.cs base class behavior
• [ ] Add integration tests for at least 2 specialized converters (e.g., ConversionJob_FFMPEG.cs and ConversionJob_Office.cs)
• [ ] Add test coverage reporting configuration to .csproj files

Add GitHub Actions workflow for automated builds and release artifacts

The repo has issue templates in .github/ISSUE_TEMPLATE/ but no CI/CD workflows. Given that FileConverter is a Windows desktop application with external dependencies (FFMPEG, ImageMagick, Office), automated builds would catch integration issues early. A release workflow would also streamline the publishing process to file-converter.io.

• [ ] Create .github/workflows/build.yml to compile on push/PR for .NET Framework
• [ ] Add workflow step to verify external tool dependencies are available
• [ ] Create .github/workflows/release.yml to build artifacts on tagged releases
• [ ] Document build prerequisites in README or CONTRIBUTING.md
• [ ] Add badge to README showing build status

Refactor ConversionPreset settings classes and add schema validation

The ConversionPreset folder has multiple related classes (ConversionPreset.cs, ConversionSettings.cs, ConversionSettingsOverride.cs, IConversionSettings.cs) that likely serialize to/from config files. There's no visible validation logic. Adding a schema validator and consolidating overlapping concerns would improve code maintainability and catch invalid user configurations early.

• [ ] Create ConversionPreset/PresetValidator.cs with validation logic for required fields
• [ ] Add unit tests in Tests/ for PresetValidator covering valid/invalid preset scenarios
• [ ] Update ConversionPreset.cs to use the validator on load/save operations
• [ ] Document the preset schema (JSON/XML) in wiki or code comments
• [ ] Consider extracting shared settings logic from ConversionSettings and ConversionSettingsOverride into a base class

• Add unit tests for ConversionJobFactory.cs — currently no test directory visible in file listing; tests could cover format routing logic and edge cases like unknown file types.
• Expand German/Spanish/French localization coverage — Properties/Resources.de-DE.resx and other locale files exist but completeness unknown; identify untranslated strings in UI controls and add them.
• Document the ConversionJob extension pattern in README — no contributor guide visible; write a step-by-step guide (with code examples) showing how to add support for a new file format using ConversionJob_NewFormat.cs.

• High · External Process Execution - FFMPEG Integration — Application/FileConverter/ConversionJobs/ConversionJob_FFMPEG.cs, ConversionJob_ImageMagick.cs, ConversionJob_Office.cs. The codebase contains multiple ConversionJob files that execute external processes (FFMPEG, ImageMagick, Office applications). The files ConversionJob_FFMPEG.cs, ConversionJob_ImageMagick.cs, and others suggest direct execution of external tools. Without proper input validation and sanitization, this could lead to command injection attacks if file paths or conversion parameters are not properly escaped. Fix: Implement strict input validation and sanitization for all file paths and parameters passed to external processes. Use ProcessStartInfo with UseShellExecute=false and properly escape all arguments. Avoid constructing command strings dynamically.
• High · Potential Path Traversal Vulnerability — Application/FileConverter/PathHelpers.cs, Application/FileConverter/ConversionJobs/. The PathHelpers.cs file is present in the codebase, suggesting path manipulation operations. Conversion jobs accept file paths as input from the Windows Explorer context menu. If these paths are not properly validated, an attacker could potentially traverse directories and convert/compress sensitive files outside intended locations. Fix: Implement strict path validation to ensure all file operations are confined to intended directories. Use Path.GetFullPath() and verify the resolved path is within an allowed directory. Reject any paths containing '..' or other traversal sequences.
• Medium · Registry Operations Without Validation — Application/FileConverter/Registry.cs. The Registry.cs file indicates direct registry manipulation. Windows registry operations could be exploited if not properly validated, potentially allowing reading/writing of sensitive registry entries or system configuration. Fix: Audit all registry operations to ensure only intended registry hives and keys are accessed. Implement whitelist-based validation for registry paths. Consider using Windows APIs with appropriate access control checks.
• Medium · XML Deserialization Without Type Safety — Application/FileConverter/IXmlSerializable.cs, Application/FileConverter/ConversionPreset/. The presence of IXmlSerializable.cs and multiple .resx resource files suggests XML deserialization operations. Unsafe XML deserialization can lead to XXE (XML External Entity) attacks or deserialization of untrusted types. Fix: When implementing IXmlSerializable, ensure XmlReaderSettings has ProhibitDtd set to true and XmlResolver set to null. Avoid using BinaryFormatter. Validate and sanitize all XML input before deserialization.
• Medium · Unsafe COM Interop with Office Applications — Application/FileConverter/ConversionJobs/ConversionJob_Word.cs, ConversionJob_Excel.cs, ConversionJob_PowerPoint.cs. Multiple Office-related conversion job files (ConversionJob_Word.cs, ConversionJob_Excel.cs, ConversionJob_PowerPoint.cs) indicate COM interop usage. Improper COM object handling could lead to security vulnerabilities or privilege escalation. Fix: Ensure all COM objects are properly released using try-finally blocks or using statements. Validate document content before processing. Consider running Office operations in isolated processes with minimal privileges.
• Medium · No Visible Cryptography Implementation — Application/FileConverter/ConversionPreset/ConversionSettings.cs, Application/FileConverter/Properties/Settings.Designer.cs. The ConversionSettings and related preset files suggest persistent storage of user preferences and settings. If sensitive data (paths, credentials, or conversion parameters) is stored without encryption, it could be exposed. Fix: Identify if sensitive data is stored in settings. If so, encrypt sensitive values using DPAPI (Data Protection API) or similar mechanisms. Never store credentials in plain text.
• Low · Lack of Input Size Validation — Application/FileConverter/ConversionJobs/ConversionJob.cs. No visible file size or resource consumption limits in ConversionJob files. This could enable Denial of Service attacks through processing extremely large files. Fix: Implement file size and resource consumption limits. Validate file sizes before processing. Implement timeouts for conversion operations. Monitor memory and CPU usage during conversions.
• Low · Missing Security Logging — undefined. undefined Fix: undefined

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.