DeskPilot.psd1
|
@{ RootModule = 'DeskPilot.psm1' ModuleVersion = '0.5.0' GUID = 'b8f3a2d1-7c4e-4a9b-9f1d-2e6c5a0b3d77' Author = 'Raimund Andree' CompanyName = 'Raimund Andree' Copyright = '(c) Raimund Andree. MIT licensed.' Description = 'DeskPilot is a local, desktop-style web UI that fronts the ShellPilot engine to give non-technical users the full GitHub Copilot agent toolset (browse, read/write files, run commands, skills, instructions) with visible permissions and honest cost - no terminal or IDE required. The web UI is bundled in the module and served on loopback; ShellPilot and a Copilot-enabled GitHub account are required.' PowerShellVersion = '7.0' FunctionsToExport = 'Start-DeskPilot' CmdletsToExport = @() VariablesToExport = @() AliasesToExport = @() PrivateData = @{ PSData = @{ Tags = @('Copilot', 'GitHubCopilot', 'ShellPilot', 'Agent', 'AI', 'GUI', 'AgenticOperatingModel', 'PSEdition_Core', 'Windows', 'Linux', 'macOS') LicenseUri = 'https://github.com/raandree/DeskPilot/blob/main/LICENSE' ProjectUri = 'https://github.com/raandree/DeskPilot' IconUri = 'https://raw.githubusercontent.com/raandree/DeskPilot/main/source/web/assets/logo-mark.png' ReleaseNotes = '## [0.5.0-preview0011] - 2026-08-12 ### Added - **A way to measure whether any of this actually helped.** Everything above claims to close a gap against VS Code Copilot; none of it proved anything. A new parity eval harness under `tests/live/eval/` runs a corpus of tasks that were genuinely attempted — starting with the two failures that began this work — against a pinned copy of a real repository, and grades the result against facts rather than impressions: did it run the authoritative test gate, did it use the search tool instead of the shell, did it leave the working tree alone when told to, did it commit when it was not asked to. Speed, tokens and cost are reported beside the result but never graded — a cheaper answer that is wrong is not better. Two runs can be compared, and a task that used to pass and now fails is reported as a regression and fails the run. It costs real credits, so it never runs as part of the normal test suite; the grading logic itself is unit-tested against recorded examples and makes no calls at all. - **A job can now keep a record of what it actually did.** Until now nothing joined up a job''s history: the live progress vanished as it scrolled, the tool calls arrived as an unordered set, and the thinking pane was one long string — so when a job went wrong there was no way to see the order things happened in. A new **Turn transcript** writes one file per job listing every step in sequence: each tool call with its timestamp and which round of the job it belonged to, when the agent was talking, when it updated its task list, and how the job ended. It is deliberately a *summary*, never a copy: a tool call records the command it ran or the file it touched and nothing else — never a file''s contents, never a command''s output, and never the agent''s own words, which are already kept with the message. Each entry says how many characters there were, so nothing is silently hidden. Transcripts live in your DeskPilot data folder, are pruned automatically once they get old or bulky, and can be fetched back through the local API. It is a diagnostic and it writes files, so it is **off** by default (`turnTranscript`). - **The agent can change three lines without rewriting the file.** Until now its only way to edit anything was to write the file out whole — so changing a couple of lines in a 900-line file meant reproducing the other 898 from memory, and whatever it failed to reproduce was simply gone. On a large file that is not a risk, it is the expected outcome. A new **replace_in_file** tool changes one exact block of text and leaves every other byte alone: your file''s encoding, its byte-order mark and its line endings all survive, so a three-line change shows up in the Changes card as three lines rather than as a whole-file rewrite you cannot review. The text it is asked to replace has to appear **exactly once** — if it appears twice, or not at all, the tool refuses and the file is left untouched, because an edit that lands in the wrong place is worse than an edit that does not happen. It is confined to your selected Project on the same terms as the search tools, refuses binary files, and follows the **File access** permission. Edits made through it appear in the Activity card and in the Changes card, so **Undo** still puts everything back. - **The agent can search your project.** It had no search of any kind: to find a file by name, or find where something is defined, it had to fall back to running a shell command and reading the console output that came back. That is slow and awkward enough that it mostly did not bother, and answered from less evidence than it could have. Two new tools make looking things up cheap — **search_files** finds files by name or pattern (`**/*.ps1`, `source/Private/*.ps1`), and **search_text** finds a string or a regular expression inside them and reports the file, the line number and the line. Both are confined to your selected Project and cannot be pointed anywhere else: an absolute path, a drive letter or a `..` is refused. Both skip whatever your `.gitignore` skips, never look in `.git`, `node_modules`, `output`, `bin` or `obj`, and skip binary files. Results are capped and time-boxed, and a capped result always says so, so the agent is never quietly told that something does not exist when it simply did not fit. The tools follow the **File access** permission: with file access off they are not offered at all, and with no Project selected they ask you to select one rather than searching anything else. - **The agent is told what is in your project before it starts.** It used to be given the folder''s *path* and nothing else, so it began every job blind: to learn which branch you are on, whether you have uncommitted work, or even which files exist, it had to go and look — and often it simply did not bother and answered from the path alone. Each job now opens with a short description of the project: the current branch and what it tracks, whether the working tree has uncommitted changes, and a listing of the files. The listing is deliberately bounded — it skips anything your `.gitignore` skips, never shows `.git`, `node_modules`, `output`, `bin` or `obj`, and where a folder is too deep or too large it is summarised as `name/ (12 files)` rather than cut off, so the agent knows there is more and can look inside. Gathering it is capped at two seconds: a very large or slow folder simply contributes nothing rather than delaying the job. A new **Describe the project folder to the agent** setting turns it off on a very large repository. - **A job that runs out of steps now tells you, and keeps its work.** The step budget rose from 25 to 50 — 25 cut off real work such as auditing a repository or running a build and diagnosing it. **200 is the recommended maximum**, and you can go above it, up to 1000, once you have confirmed a warning: every step is a paid round trip, and a job that long can outlive its own sign-in token and stop with an error it cannot recover from. So a deliberate long job is allowed while a typo still cannot start an expensive runaway. The agent is also told how many steps it has, so it can spend them deliberately instead of being cut off mid-thought. When a job does hit the limit it no longer disappears into an error: it ends like a stopped job, explains that it ran out of budget, points at the setting, and keeps everything it had already said and planned. - **Workspace-wide instructions now actually apply.** An instruction file that applies to everything was only ever *offered* to the agent, which had to decide to go and fetch it — and often did not, so rules you had written were quietly not in force. Instruction files whose `applyTo` is `**` are now put straight into the agent''s brief at the start of every job. Instructions scoped to particular files are unchanged: the agent still fetches those when they become relevant. A new **Always apply workspace-wide instructions** setting turns this off if you would rather save the context on a small model. - **See what the agent said while it worked.** A job that used several tools narrated its way through them — "let me check the branch first", "the counts differ, so I will find out why" — and every word of it was thrown away the moment the job finished, leaving only the final answer. Those notes are now kept in a **Steps** section above the answer, one entry per tool the agent reached for. It is collapsed by default, it survives a reload, and a job you stop keeps whatever it had already said — which is often the only record of what it was doing. - **Watch the files being edited, while they are edited.** Until a job finished, the only place that named the file the agent was writing was the thinking trace — so with **Show the model''s thinking** switched off, nothing named it at all. A card now appears under the answer as the job runs and lists each file the moment the agent starts writing it. When the job ends, the reviewed card you already know — with the `+`/`−` counts, **Keep** and **Undo** — takes its place. A job you stop, or one in a folder that is not a repository, keeps the list instead of clearing it, so you can still see what was written. - **Pick the model from your phone.** Intercom could switch the conversation, the agent and the project, but not the model, so choosing one still meant walking back to the machine. `/models` lists the models your account is offered, marks the one your next instruction would run on and gives you a button per model; `/model 2` picks one and `/model default` goes back to the standard one. `/status` now names the model too. A switch applies to your next instruction — it never disturbs a job already running — and it changes both the default and the conversation you are in, so the model you were told about is the model that actually runs. While a job is running and the list has never been loaded, `/models` says so and asks you to try again afterwards rather than freezing DeskPilot to go and fetch it. - **Switch agent and project from your phone.** Intercom could switch conversations but not the two things that decide *how* and *where* the agent works. `/agents` lists the agents you have, marks the one in use and gives you a button per agent; `/agent 2` picks one and `/agent none` goes back to the default. `/projects` does the same for your projects and says on every line which ones you are allowed to work in from your phone, so you learn that before you send an instruction rather than from a refusal. `/project new C:\Git\Notes` registers a folder as a project — creating that last folder if it does not exist yet — and `/status` now names the agent in use. A project added from your phone is deliberately **not** remote-controllable until you' Prerelease = 'preview0011' } } } |