fix(powershell): Get-ChildItem's table, PowerShell's parameters and messages for file cmdlets

[thierryvm]

Summary

Windows learners saw a Linux terminal wearing a PowerShell prompt: ls printed bare names, ls -la worked, dot files were "hidden", and rm -rf deleted folders. This PR makes the Windows environment answer like PowerShell 7.6. Every expected value comes from a real pwsh capture (en-US, 1 October 2026).

Get-ChildItem (ls, dir, gci)

• Prints PowerShell's table: Directory: C:\…, then Mode / LastWriteTime / Length / Name, folders first, case-insensitive order. Length is the UTF-8 byte count.
• Dot files are ordinary files. Only .git is hidden (d--h-), and -Force shows it.
• -Name, -Force, -Hidden, -Recurse, -Depth, -Directory, -File, -Filter and a wildcard in the path all work.
• Prints its table into > file, | Tee-Object and | Out-File. Into any other cmdlet it emits one name per line, so | Measure-Object counts items.
• Measure-Object prints PowerShell's full list.

Parameter binding (commands/psParams.ts, shared by Get-ChildItem, Remove-Item, Copy-Item and Move-Item)

• Names resolve as PowerShell resolves them: own parameters, then common ones, then the file system's. Prefixes work, and an ambiguous prefix gets PowerShell's message (ls -a, rm -f, cp -p).
• "Missing an argument" names the real .NET type.
• -Name:value works, bare words bind to their positions (an extra one is refused), comma lists work, and -- ends parameters.

File cmdlets

• Under Windows, rm, cp and mv are Remove-Item, Copy-Item and Move-Item. rm -rf and rm a b are refused; rm -r and rm a, b work.
• Errors are PowerShell's, with the full Windows path: New-Item, mkdir/md, Move-Item, Copy-Item, Remove-Item and Set-Location/cd.
• New-Item refuses an existing file. With -Force it empties the file, and with -ItemType Directory -Force (or mkdir -Force) an existing folder is accepted.
• Move-Item does not overwrite a file without -Force, and renames to dir when dir/ is missing.
• Remove-Item deletes an empty folder without -Recurse. For a non-empty one it shows a note instead of the interactive confirmation it cannot simulate.
• Copy-Item without -Recurse copies the folder, empty.

Content

• The ls and ls -la lessons get a PowerShell version (contentByEnv). Ratchet: bash shown on Windows 34 → 32.
• The Reference page explains Get-ChildItem's columns and -Name, and adds two pitfalls: ls -la and rm -rf in PowerShell.
• CHANGELOG 🪟 entry and a STORY chapter (Part VIII).

Verification

• terminal-fidelity-auditor, 175 commands against real pwsh 7.6: the Get-ChildItem table and every lesson block MATCH, 0 THEORY-WRONG. This PR fixes F1 (parameter types), F3 (formatting consumers), F4 (Measure-Object), F5 (rm/cp/mv aliases), F10 (Copy-Item folder) and part of F12 (Remove-Item on an empty folder).
• feature-dev:code-reviewer, two passes: the first found no CRITICAL or IMPORTANT issue, and its three minor points (New-Item -Force, ls > file, -Path:x) are fixed. The second pass found one IMPORTANT issue, extra positionals silently ignored; it is fixed and checked against real pwsh.
• Gates: tsc, lint, vitest (3022 passed), build. theory:gaps 90 → 90, bash shown on Windows 32 → 32.

Not in this PR (Windows debt, tracked)

• New-Item and mkdir do not print the table of the item they create (F7).
• Paths are case-sensitive under Windows (F2: ls DOCUMENTS).
• mkdir a b (F6).
• Move-Item onto itself or into its own subfolder (F8, F9).
• Copy-Item into a missing parent (F11).
• cd to a file (F13).
• | Select-Object / | Sort-Object after Get-ChildItem print names instead of the table (F3, other cmdlets).
• A redirection target does not list itself when you redirect the current folder's listing.

🤖 Generated with Claude Code

Résumé par Sourcery

Faire en sorte que le terminal Windows reproduise fidèlement les listes de répertoires PowerShell, la gestion des paramètres, les opérations sur les fichiers, le formatage de la sortie et la documentation destinée aux apprenants.

Nouvelles fonctionnalités :

• Faire en sorte que les listes de répertoires Windows et les alias de gestion des fichiers se comportent comme dans PowerShell, notamment les tableaux Get-ChildItem, le filtrage, la récursivité et la liaison de paramètres compatible avec PowerShell.
• Fournir un comportement spécifique à PowerShell pour rm, cp, mv, New-Item, ainsi que pour la suppression et la copie de répertoires, y compris les alias, les arguments positionnels et les messages d’erreur courants.

Corrections de bugs :

• Corriger la sortie des leçons Windows et les indications de commande afin que les apprenants voient la syntaxe et la sémantique PowerShell plutôt qu’un comportement Unix.
• Aligner la sortie des pipelines PowerShell, de la redirection, de Tee-Object, de Out-File et de Measure-Object sur le formatage attendu.

Améliorations :

• Ajouter une résolution partagée des paramètres PowerShell pour les cmdlets de fichiers, notamment les paramètres abrégés et ambigus, les valeurs typées, les listes et la terminaison des paramètres.
• Améliorer les rapports d’erreur du système de fichiers Windows avec les chemins complets et des messages compatibles avec PowerShell.

Documentation :

• Mettre à jour le journal des modifications, les exemples de commandes de référence, les leçons du programme pédagogique et l’histoire du projet avec le comportement et les pièges de Windows PowerShell.

Tests :

• Ajouter une couverture complète pour le formatage, le filtrage, la récursivité, les alias, la liaison de paramètres, les pipelines, les cmdlets de fichiers et le comportement des erreurs Windows de Get-ChildItem.

Tâches de maintenance :

• Réduire de 34 à 32 le nombre autorisé de leçons présentant Bash aux apprenants utilisant Windows.

Original summary in English

Summary by Sourcery

Make the Windows terminal faithfully model PowerShell directory listings, parameter handling, file operations, output formatting, and learner-facing documentation.

New Features:

• Make Windows directory listings and file-management aliases behave like PowerShell, including Get-ChildItem tables, filtering, recursion, and PowerShell-compatible parameter binding.
• Provide PowerShell-specific behavior for rm, cp, mv, New-Item, and directory removal and copying, including aliases, positional arguments, and common error messages.

Bug Fixes:

• Correct Windows lesson output and command guidance so learners see PowerShell syntax and semantics instead of Unix behavior.
• Align PowerShell pipeline, redirection, Tee-Object, Out-File, and Measure-Object output with expected formatting.

Enhancements:

• Add shared PowerShell parameter resolution for file cmdlets, including abbreviated and ambiguous parameters, typed values, lists, and parameter termination.
• Improve Windows filesystem error reporting with full paths and PowerShell-compatible messages.

Documentation:

• Update the changelog, reference command examples, curriculum lessons, and project story with Windows PowerShell behavior and pitfalls.

Tests:

• Add comprehensive coverage for Get-ChildItem formatting, filtering, recursion, aliases, parameter binding, pipelines, file cmdlets, and Windows error behavior.

Chores:

• Reduce the allowed count of lessons that show Bash to Windows learners from 34 to 32.

[vercel]

The latest updates on your projects. Learn more about Vercel for GitHub.

Project	Deployment	Actions	Updated
terminal-learning	Ready	Preview	Oct 1, 2026 8:48pm UTC

[sourcery-ai]

Sorry @thierryvm, you've used your own review budget of 250,000 diff characters for the last 7 days.

You can request another review in 2 days and 15 hours by commenting @sourcery-ai review. Upgrade to get a review now.

[sourcery-ai]

Guide du reviewer

Cette PR remplace la simulation des commandes de fichiers de type Unix sous Windows par une implémentation partagée orientée PowerShell 7.6 : Get-ChildItem formate désormais les listes et les pipelines comme PowerShell, les cmdlets de fichiers partagent une liaison réaliste des paramètres et des alias, les erreurs Windows et les cas limites du système de fichiers sont alignés sur le comportement capturé de PowerShell, et les leçons, tests et documents ont été mis à jour en conséquence.

Diagramme de séquence pour la sortie Get-ChildItem de style PowerShell

sequenceDiagram
    actor User
    participant Engine as TerminalEngine
    participant Binder as parsePsArgs
    participant ChildItems as cmdChildItem
    participant FS as VirtualFilesystem
    participant Sink as OutputSink

    User->>Engine: ls -Force
    Engine->>ChildItems: childItems(state, args)
    ChildItems->>Binder: parsePsArgs(GET_CHILD_ITEM, args)
    Binder-->>ChildItems: switches and values
    ChildItems->>FS: enumerate matching children
    FS-->>ChildItems: folders and files
    ChildItems->>ChildItems: format table rows
    ChildItems-->>Engine: Directory, Mode, LastWriteTime, Length, Name
    Engine->>Sink: write formatted table

Loading

Diagramme de séquence pour la liaison partagée des paramètres PowerShell

sequenceDiagram
    actor User
    participant Engine as TerminalEngine
    participant Binder as parsePsArgs
    participant Resolver as resolvePsParam
    participant Cmdlet as FileCmdlet

    User->>Engine: rm -r a.txt
    Engine->>Binder: parsePsArgs(REMOVE_ITEM, args)
    Binder->>Resolver: resolvePsParam(REMOVE_ITEM, r)
    Resolver-->>Binder: Recurse
    Binder->>Binder: bind positional Path
    Binder-->>Engine: PsArgs
    Engine->>Cmdlet: Remove-Item with Recurse and Path
    Cmdlet-->>Engine: command result

    User->>Engine: rm -rf a.txt
    Engine->>Binder: parsePsArgs(REMOVE_ITEM, args)
    Binder->>Resolver: resolvePsParam(REMOVE_ITEM, rf)
    Resolver-->>Binder: parameter-not-found error
    Binder-->>Engine: PowerShell error

Loading

Diagramme de flux pour les alias des cmdlets de fichiers PowerShell

flowchart TD
    Command["Windows file command"] --> Alias{"Alias resolution"}
    Alias -->|ls / dir / gci| GCI["Get-ChildItem"]
    Alias -->|rm / ri / del| Remove["Remove-Item"]
    Alias -->|cp / copy| Copy["Copy-Item"]
    Alias -->|mv / move| Move["Move-Item"]
    GCI --> Binding["Shared PowerShell parameter binding"]
    Remove --> Binding
    Copy --> Binding
    Move --> Binding
    Binding --> Execution["Filesystem operation and PowerShell errors"]

Loading

Modifications au niveau des fichiers

Modification	Détails	Fichiers
Implémentation d’un chemin de listage et de formatage de sortie Get-ChildItem compatible avec PowerShell pour Windows.	Ajout du formatage en tableau avec en-têtes de répertoires, colonnes, ordre, longueurs UTF-8, comportement des éléments masqués, filtres, jokers, récursivité, profondeur et sortie limitée aux noms. Ajout d’un formatage adapté aux pipelines afin que l’écran, la redirection, Tee-Object, Out-File et Measure-Object reçoivent des représentations similaires à celles de PowerShell. Ajout d’exemples de leçons Windows et d’une couverture ciblée du shell et du moteur.	src/app/data/terminalEngine.ts src/app/data/commandExamples.ts src/app/data/curriculum.ts src/test/shellLayer.test.ts src/test/terminalEngine.test.ts
Centralisation des métadonnées de paramètres PowerShell et de la liaison des arguments pour les cmdlets liées aux fichiers.	Ajout de la résolution des paramètres spécifiques aux cmdlets, communs et dynamiques avec noms exacts, alias, préfixes, erreurs d’ambiguïté, messages typés en cas d’argument manquant, valeurs intégrées, liaison positionnelle, listes séparées par des virgules et terminaison avec --. Partage du mécanisme de liaison entre Get-ChildItem, Remove-Item, Copy-Item et Move-Item, y compris les notifications concernant les paramètres non pris en charge.	src/app/data/commands/psParams.ts src/app/data/commands/windows.ts src/app/data/terminalEngine.ts
Alignement des alias de fichiers Windows et du comportement et des messages des cmdlets de fichiers sur la sémantique de PowerShell.	Association des alias ls/dir/gci et rm/cp/mv aux implémentations PowerShell, tout en préservant le comportement Unix dans les environnements non Windows. Ajustement de la gestion de New-Item, Remove-Item, Copy-Item, Move-Item, mkdir et cd pour le comportement forcé, les règles de remplacement, les dossiers vides ou non vides, les copies de dossiers, les renommages de destination et les erreurs complètes de chemins Windows. Ajout du comptage des éléments enfants et des utilitaires du système de fichiers nécessaires aux décisions spécifiques à PowerShell.	src/app/data/commands/windows.ts src/app/data/terminalEngine.ts src/test/terminalEngine.test.ts src/test/shellLayer.test.ts
Mise à jour du contenu pédagogique et de la documentation du projet afin d’expliquer l’expérience Windows PowerShell.	Ajout de versions et d’exemples spécifiques à Windows pour les leçons sur ls, notamment les colonnes du tableau, -Name, -Force et les pièges de PowerShell. Mise à jour des recommandations du catalogue de commandes, du journal des modifications, du chapitre STORY et du ratchet bash-on-Windows.	src/app/data/curriculum.ts src/app/data/commandExamples.ts src/app/data/commandCatalogue.ts CHANGELOG.md STORY.md src/test/lessonTheoryGaps.ts

---

Conseils et commandes

Interagir avec Sourcery

• Déclencher une nouvelle review : commentez @sourcery-ai review sur la pull request.
• Poursuivre les discussions : répondez directement aux commentaires de review de Sourcery.
• Générer une issue GitHub à partir d’un commentaire de review : demandez à Sourcery de créer une issue à partir d’un commentaire de review en y répondant. Vous pouvez également répondre à un commentaire de review avec @sourcery-ai issue pour créer une issue à partir de celui-ci.
• Générer un titre de pull request : écrivez @sourcery-ai n’importe où dans le titre de la pull request pour générer un titre à tout moment. Vous pouvez également commenter @sourcery-ai title sur la pull request pour générer ou régénérer le titre à tout moment.
• Générer un résumé de pull request : écrivez @sourcery-ai summary n’importe où dans le corps de la pull request pour générer un résumé de PR à tout moment, exactement à l’endroit souhaité. Vous pouvez également commenter @sourcery-ai summary sur la pull request pour générer ou régénérer le résumé à tout moment.
• Générer le guide du reviewer : commentez @sourcery-ai guide sur la pull request pour générer ou régénérer le guide du reviewer à tout moment.
• Résoudre tous les commentaires de Sourcery : commentez @sourcery-ai resolve sur la pull request pour résoudre tous les commentaires de Sourcery. Cette option est utile si vous avez déjà traité tous les commentaires et ne souhaitez plus les voir.
• Ignorer toutes les reviews de Sourcery : commentez @sourcery-ai dismiss sur la pull request pour ignorer toutes les reviews existantes de Sourcery. Cette option est particulièrement utile si vous souhaitez repartir de zéro avec une nouvelle review. N’oubliez pas de commenter @sourcery-ai review pour déclencher une nouvelle review !

Personnaliser votre expérience

Accédez à votre tableau de bord pour :

• Activer ou désactiver des fonctionnalités de review telles que le résumé de pull request généré par Sourcery, le guide du reviewer et d’autres fonctionnalités.
• Modifier la langue de review.
• Ajouter, supprimer ou modifier des instructions de review personnalisées.
• Ajuster d’autres paramètres de review.

Obtenir de l’aide

• Contactez notre équipe d’assistance pour toute question ou remarque.
• Consultez notre documentation pour obtenir des guides et des informations détaillés.
• Restez en contact avec l’équipe Sourcery en nous suivant sur X/Twitter, LinkedIn ou GitHub.

Original review guide in English

Reviewer's Guide

This PR replaces the Windows Unix-like file-command simulation with a shared PowerShell 7.6-oriented implementation: Get-ChildItem now formats listings and pipelines like PowerShell, file cmdlets share realistic parameter binding and aliases, Windows errors and filesystem edge cases are aligned with captured PowerShell behavior, and lessons/tests/documentation are updated accordingly.

Sequence diagram for PowerShell-style Get-ChildItem output

sequenceDiagram
    actor User
    participant Engine as TerminalEngine
    participant Binder as parsePsArgs
    participant ChildItems as cmdChildItem
    participant FS as VirtualFilesystem
    participant Sink as OutputSink

    User->>Engine: ls -Force
    Engine->>ChildItems: childItems(state, args)
    ChildItems->>Binder: parsePsArgs(GET_CHILD_ITEM, args)
    Binder-->>ChildItems: switches and values
    ChildItems->>FS: enumerate matching children
    FS-->>ChildItems: folders and files
    ChildItems->>ChildItems: format table rows
    ChildItems-->>Engine: Directory, Mode, LastWriteTime, Length, Name
    Engine->>Sink: write formatted table

Loading

Sequence diagram for shared PowerShell parameter binding

sequenceDiagram
    actor User
    participant Engine as TerminalEngine
    participant Binder as parsePsArgs
    participant Resolver as resolvePsParam
    participant Cmdlet as FileCmdlet

    User->>Engine: rm -r a.txt
    Engine->>Binder: parsePsArgs(REMOVE_ITEM, args)
    Binder->>Resolver: resolvePsParam(REMOVE_ITEM, r)
    Resolver-->>Binder: Recurse
    Binder->>Binder: bind positional Path
    Binder-->>Engine: PsArgs
    Engine->>Cmdlet: Remove-Item with Recurse and Path
    Cmdlet-->>Engine: command result

    User->>Engine: rm -rf a.txt
    Engine->>Binder: parsePsArgs(REMOVE_ITEM, args)
    Binder->>Resolver: resolvePsParam(REMOVE_ITEM, rf)
    Resolver-->>Binder: parameter-not-found error
    Binder-->>Engine: PowerShell error

Loading

Flow diagram for PowerShell file-cmdlet aliases

flowchart TD
    Command["Windows file command"] --> Alias{"Alias resolution"}
    Alias -->|ls / dir / gci| GCI["Get-ChildItem"]
    Alias -->|rm / ri / del| Remove["Remove-Item"]
    Alias -->|cp / copy| Copy["Copy-Item"]
    Alias -->|mv / move| Move["Move-Item"]
    GCI --> Binding["Shared PowerShell parameter binding"]
    Remove --> Binding
    Copy --> Binding
    Move --> Binding
    Binding --> Execution["Filesystem operation and PowerShell errors"]

Loading

File-Level Changes

Change	Details	Files
Implemented a PowerShell-compatible Get-ChildItem listing and output formatting path for Windows.	Added table formatting with directory headers, columns, ordering, UTF-8 lengths, hidden-item behavior, filters, wildcards, recursion, depth, and name-only output. Added pipeline-aware formatting so screen, redirection, Tee-Object, Out-File, and Measure-Object receive PowerShell-like representations. Added Windows lesson examples and focused shell/engine coverage.	src/app/data/terminalEngine.ts src/app/data/commandExamples.ts src/app/data/curriculum.ts src/test/shellLayer.test.ts src/test/terminalEngine.test.ts
Centralized PowerShell parameter metadata and argument binding for file-related cmdlets.	Added cmdlet-specific, common, and dynamic parameter resolution with exact names, aliases, prefixes, ambiguity errors, typed missing-argument messages, inline values, positional binding, comma lists, and -- termination. Shared the binder across Get-ChildItem, Remove-Item, Copy-Item, and Move-Item, including unsupported-parameter notices.	src/app/data/commands/psParams.ts src/app/data/commands/windows.ts src/app/data/terminalEngine.ts
Aligned Windows file aliases and file-cmdlet behavior with PowerShell semantics and messages.	Mapped ls/dir/gci and rm/cp/mv aliases to PowerShell implementations while preserving Unix behavior on non-Windows environments. Adjusted New-Item, Remove-Item, Copy-Item, Move-Item, mkdir, and cd handling for force behavior, overwrite rules, empty/non-empty folders, folder copies, destination renames, and full Windows-path errors. Added child-count and filesystem helpers needed for PowerShell-specific decisions.	src/app/data/commands/windows.ts src/app/data/terminalEngine.ts src/test/terminalEngine.test.ts src/test/shellLayer.test.ts
Updated educational content and project documentation to explain the Windows PowerShell experience.	Added Windows-specific versions of ls lessons and examples, including table columns, -Name, -Force, and PowerShell pitfalls. Updated command catalog guidance, changelog, STORY chapter, and the bash-on-Windows ratchet.	src/app/data/curriculum.ts src/app/data/commandExamples.ts src/app/data/commandCatalogue.ts CHANGELOG.md STORY.md src/test/lessonTheoryGaps.ts

---

Tips and commands

Interacting with Sourcery

• Trigger a new review: Comment @sourcery-ai review on the pull request.
• Continue discussions: Reply directly to Sourcery's review comments.
• Generate a GitHub issue from a review comment: Ask Sourcery to create an
  issue from a review comment by replying to it. You can also reply to a
  review comment with @sourcery-ai issue to create an issue from it.
• Generate a pull request title: Write @sourcery-ai anywhere in the pull
  request title to generate a title at any time. You can also comment
  @sourcery-ai title on the pull request to (re-)generate the title at any time.
• Generate a pull request summary: Write @sourcery-ai summary anywhere in
  the pull request body to generate a PR summary at any time exactly where you
  want it. You can also comment @sourcery-ai summary on the pull request to
  (re-)generate the summary at any time.
• Generate reviewer's guide: Comment @sourcery-ai guide on the pull
  request to (re-)generate the reviewer's guide at any time.
• Resolve all Sourcery comments: Comment @sourcery-ai resolve on the
  pull request to resolve all Sourcery comments. Useful if you've already
  addressed all the comments and don't want to see them anymore.
• Dismiss all Sourcery reviews: Comment @sourcery-ai dismiss on the pull
  request to dismiss all existing Sourcery reviews. Especially useful if you
  want to start fresh with a new review - don't forget to comment
  @sourcery-ai review to trigger a new review!

Customizing Your Experience

Access your dashboard to:

• Enable or disable review features such as the Sourcery-generated pull request
  summary, the reviewer's guide, and others.
• Change the review language.
• Add, remove or edit custom review instructions.
• Adjust other review settings.

Getting Help

• Contact our support team for questions or feedback.
• Visit our documentation for detailed guides and information.
• Keep in touch with the Sourcery team by following us on X/Twitter, LinkedIn or GitHub.