agentleFS
bekalpaslanbekalpaslan/promptline/CLAUDE.md

promptline

CLAUDE.md13 starsChanged 6 days agoMITView on GitHub

A Tauri 2 tray app for Windows: Rust in src-tauri/src/ (lib.rs holds AppState, the tray and run(); store.rs files and atomic writes, packs.rs pack metadata and files, commands.rs the Tauri commands (the paste and update ones live in paste.rs and update.rs), paste.rs the popup and paste pipeline, platform.rs the Win32 calls, update.rs the update check, migrations.rs old data), two React windows (index.html = manager, popup.html = popup) built by one Vite config, pure logic in ui/core.js (plain UMD, tested with…

  • Reads credentials
  • Deletes or force-pushes
  • Commits and pushes

The file

We split this CLAUDE.md into the rules it gives an agent

10 rules. About 0 are common, 3 are distinctive, and 7 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈3

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 7

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Every box carries sources (file and line) read at the commit in meta.repository.revision, not the working tree.

    line 142
  2. Very specific:

    Remove finished worktrees (git worktree remove): each holds its own node_modules and Rust target/, and the harness leaves a lock on the …

    line 227
  3. Distinctive:

    Write multi-line edit scripts to a file with the Write tool and run them.

    line 245
  4. Very specific:

    Look at the change running, not just the diff.

    line 263
  5. Very specific:

    Stop the installed app first (%LOCALAPPDATA%\Promptline\promptline.exe): it shares the WebView2 profile, and a second instance with other …

    line 306
  6. Very specific:

    Run npm run ui:dev (port 5173), then launch src-tauri/target/debug/promptline.exe with …

    line 311
  7. Distinctive:

    Finish the tree: After merging, git worktree remove --force every agent worktree (unlock first if the harness left a lock), delete the …

    line 346
  8. Distinctive:

    If windows, commands, events or storage changed since the last map refresh, refresh the architecture map against the tagged commit (its own …

    line 468
  9. Very specific:

    Commit subjects are sentence case, often prefixed with the surface (Manager: …, Popup: …, Rust: …, Core: …).

    line 531
  10. Very specific:

    Every Tauri command the webview can call takes no path it hasn't been given by Rust (read_pack_file, show_in_folder refuse paths outside …

    line 555

≈ “Common” is an estimate: at least 1 in 5 of the 27,641 CLAUDE.md files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
CLAUDE.md

Promptline — notes for agents

A Tauri 2 tray app for Windows: Rust in src-tauri/src/ (lib.rs holds AppState, the tray and run(); store.rs files and atomic writes, packs.rs pack metadata and files, commands.rs the Tauri commands (the paste and update ones live in paste.rs and update.rs), paste.rs the popup and paste pipeline, platform.rs the Win32 calls, update.rs the update check, migrations.rs old data), two React windows (index.html = manager, popup.html = popup) built by one Vite config, pure logic in ui/core.js (plain UMD, tested with bare node --test) with its TypeScript face in src/lib/core.ts. Every build carries the updater (the store build that compiled it out went with the Microsoft Store listing on 2026-10-29; Promptline is donations only, nothing is sold).

Released as v0.2.9 on 2026-09-23 after a full audit; everything that audit found is closed (docs/history/RELEASE-AUDIT.md). Start from the backlog, not from another audit, unless asked.

Where things are written down

  • BEHAVIOR.md — how each surface behaves and why. Read the section for what you're changing first; update it in the same commit when behaviour changes.
  • README.md — the app as a user sees it.
  • BACKLOG.md — deferred ideas. Add to it rather than widening a change.
  • docs/MARKETING.md — the marketing strategy and the decisions behind it (donations only, source stays MIT; a Windows-only round once Certum signs a release, Show HN held for the macOS port; community packs as repo files first). Exported from a Claude doc; refresh the export when a decision changes. Local only since 2026-09-26: untracked and listed in .git/info/exclude, so a fresh clone doesn't have it. What success means for Promptline, so a clone has it too: people reached and kept, read from the GitHub and package-manager numbers scripts/snapshot.mjs prints (downloads of the stable Promptline-setup.exe are people reached; from 0.2.28 downloads of the -update copies only the feed links are people kept, read with --releases against the site downloads of every release before it; older releases read versioned fetches minus the per-release machinery floor instead). The one-second copy-hotkey-paste gesture is the means to that, not the measure.
  • docs/history/ — the review, audit and benchmark trackers (REVIEW.md, RELEASE-AUDIT.md, BUG-HUNT-*.md) and the 2026-07 UI rework roadmap, each with its own rules at the top. Test names cite these files' finding ids (H1, M7, BH3-1), so they stay in the repo. For the next review, copy RELEASE-AUDIT.md's shape: one heading per finding with Status / Where / What / Failure / Fix, a Resolution block appended when done, a progress table at the top, and decisions for the human in their own section. The orchestrator updates the tracker from agents' reports; agents never edit it.
  • docs/architecture/ — the architecture map, for the human managing the project (see Architecture map below).
  • .claude/skills/ — the six project skills, tracked while the rest of .claude/ is ignored (each skill has its own !.claude/skills/<name>/ line in .gitignore; a new skill is invisible to git without one): monthly-theme (a theme from a Figma design, trialled as a skin over the mock, wired through the token pipeline and shelved on a theme/<id> branch; Promptline ships one theme a month since 0.2.18), release (the Releasing section below with the maintainer's standing decisions, the shelf check for the month's theme, and the scripts: version bump, map remap, updater-signature check), doc-audit (every checkable claim in the docs checked against the code and the doc fixed, one commit per doc, on a chore/doc-audit-… branch) and fresh-eyes (an open-ended improvement review where the agents, not the asker, choose the areas: blind discovery, a check of each proposal by an agent that didn't write it, one ranked report with the maintainer's decisions in their own section; read-only, with a ready-made workflow script) and dependabot (the monthly grouped PRs and the security alerts triaged by the project's standing rules: Windows is the only binary, the updater is the one network call, majors and the Tauri pair move by hand; with a triage script) and maintenance (a pass that keeps what exists healthy and true, no features or behaviour changes: the baseline checks, dependabot and doc-audit, the backlog, the map, then housekeeping, on a chore/maintenance-… branch; it never releases). /monthly-theme <figma url>, /release, /doc-audit [doc, area or "since vX.Y.Z"], /fresh-eyes, /dependabot [PR, alert or "config"] and /maintenance [step] run them.
  • site/ — the website at https://promptline.cc (the home page, posts/ and code-signing/), published to GitHub Pages by .github/workflows/pages.yml on every push to master that touches it or the images it copies (the workflow runs node scripts/site-assets.mjs --reuse-webp, which copies docs/og.png, the two icons from src-tauri/icons/, docs/screenshots/*.png and the clip's video and posters from docs/clip/ in and makes the lossless WebP the page serves, one per shot and poster; site/ holds no binaries). Plain HTML and CSS on the tokens from design/tokens.json; site/site.css holds what every page shares (the tokens, the base, the header with its phone menu, the footer, the document pages' column) and each page links it, then keeps only its own rules in an inline <style> after it (tests/site-css.test.js). The home page is a hero with the launch clip playing in the theme showing, then a tour with one chapter per screen, each shot in both themes (only the one showing loads; the header's switch pins one for the visit, nothing stored). The screenshots and the social card are made, not taken: npm run shots (e2e/shots.spec.ts) stages each screen against the demo library (?mock=showcase, e2e/showcase.json) and writes docs/screenshots/<shot>-<light|dark>.png at 2x and docs/og.png; rerun it once at the end of a session of visible UI changes, not per commit (the 2026-10-10 session regenerated every image ten times, and the repository's history stood near 69 MiB by the day's end), and commit the images. The launch clip is made the same way: npm run clip (e2e/clip.spec.ts around e2e/clip-terminal.html, a Windows Terminal running Claude Code with the real popup over it) captures each state as counted frames, so a rerun writes the same frames, and scripts/clip-encode.mjs encodes docs/clip/clip-<light|dark>.{mp4,webm,gif} plus a -poster.png; rerun it with the shots, once per session of visible popup changes, and commit the files. It needs ffmpeg once (winget install Gyan.FFmpeg, like npx playwright install chromium for the suite); without it the command stops before capturing and says so. A new page under site/ is a <url> in site/sitemap.xml and the head its siblings carry (canonical, Open Graph and Twitter tags, the /site.css link, the <noscript> style, inline JSON-LD); a post also joins the Blog list in posts/index.html's JSON-LD. A new screen is a shot in that spec plus a chapter in site/index.html; the Download button is a plain link to releases/latest/download/Promptline-setup.exe, the stable-named copy each release carries (step 5 of Releasing), so a release needs no site change. A visitor's browser loads from GitHub Pages alone, and leaves it only on a click: the Download button to GitHub Releases, the coffee links to Buy Me a Coffee (plain links, nothing of theirs embedded). The footer's privacy note names both; keep it true (no analytics, no cookies, no remote fonts or scripts). site/latest.json is the updater feed that installed copies read at https://promptline.cc/latest.json; the release step writes it (Releasing step 6), never edit it by hand, and a push that touches it deploys it. Preview it with python -m http.server in site/ after node scripts/site-assets.mjs (what it writes is gitignored there). A new <img> of a shot goes in a <picture> with the WebP <source> its siblings carry. Live with HTTPS enforced since 2026-09-23; DNS is at GoDaddy (four Pages A records, www CNAME). The bundle identifier stays io.github.bekalpaslan.promptline on purpose: it names the data folder, and a domain can lapse.

Architecture map

An archify diagram of the runtime shape: promptline.architecture.json is the current map, and alternatives/*.architecture.json are proposals drawn against it. The JSON is the source; the rendered HTML, screenshots and receipts are gitignored (about 800 KB each), so render them to look. Archify is a global skill (~/.claude/skills/archify), not a dependency: installed inside the repo, npm run lint would walk its .mjs.

Every box carries sources (file and line) read at the commit in meta.repository.revision, not the working tree. Keep that a pushed commit so the SRC links resolve on GitHub.

  • Refresh ("refresh the map") after a change to windows, commands, events or storage: set revision to the new pushed commit, fix the moved line numbers and any changed boxes or edges, then validate, deliver, visual-check (all four viewports must pass containment) and republish to the same artifact URL. A structural change updates the map in its own commit, like BEHAVIOR.md.
  • Propose by copying the map into alternatives/<idea>.architecture.json, keeping every id that doesn't change, and rendering compare against the map for a Before / Delta / After page.
  • Stories are one user scenario end to end, as a sequence diagram in stories/<scenario>.sequence.json, with lanes for the surfaces and files and function names in the message labels (sequence has no sources, and --repo-root is architecture-only). Trace the scenario in the code first; it routinely differs from the obvious guess. The viewer caps the width by the window height (about 930 px at 1440×900), so keep the viewBox about 1080 wide and at most about 610 high, and cut return arrows that add nothing before squeezing messages below 28 px apart.

Commands run from the skill directory, with --repo-root pointing at the checkout:

cd ~/.claude/skills/archify
node bin/archify.mjs validate architecture <repo>/docs/architecture/promptline.architecture.json --quality showcase --repo-root <repo> --json
node bin/archify.mjs deliver  architecture <json> <same-name>.html --quality showcase --repo-root <repo> --json
node bin/archify.mjs visual-check <html> --json
node bin/archify.mjs compare  architecture <map.json> <alternative.json> <alternative>.delta.html --repo-root <repo> --json

Published (private) as claude.ai artifacts: the map at https://claude.ai/artifact/WWYhTYdWQDFZeaHXBmwBbC, the direct-API generation delta at https://claude.ai/artifact/3ZgbonXsiQw7uxU55XPtHv, the tray-select-tag story at https://claude.ai/artifact/Ro7g4r6zpgc6DLqSzFPAtv. The Export menu does nothing inside claude.ai (no download permission); it works on the local HTML. Republishing needs the Artifact tool to have read that URL once in the session first, or the publish is refused; the "download link" warning on publish is that Export menu and is expected. A refresh took about ten minutes on 2026-09-23: grep the new line numbers, edit the JSON with a script, validate, deliver, visual-check, read, publish, commit.

Checks

Seven, and CI runs all of them on every push and PR (.github/workflows/ci.yml):

  • npx tsc -b --noEmit (the app, the Vite config and e2e/)
  • npm run lint (eslint . --max-warnings 0: a warning fails; src/ is type-checked, typescript-eslint's recommendedTypeChecked through projectService, so it needs node_modules and runs several seconds longer than the untyped set scripts/, e2e/ and design/ keep)
  • npm test (node, tests/*.test.js: core, tokens, the two parity tests below, and the site, README, clip and release-script tests)
  • npm run test:e2e (Playwright: both windows in Chromium against the fake backend, e2e/*.spec.ts; npx playwright install chromium once. It starts its own Vite on 5179, or reuses one already there; a first failure leaves a trace in test-results/, npx playwright show-trace opens it. Add a case when a UI behaviour changes, in the file for its window, named for the behaviour; assert through roles and names, and through window.__mock.calls for what the backend was asked, never through class names)
  • npm run test:rust
  • cargo fmt --manifest-path src-tauri/Cargo.toml --check
  • cargo clippy --manifest-path src-tauri/Cargo.toml --all-targets -- -D warnings (rustup component add rustfmt clippy once; both are clean today, keep them so with fixes, not #[allow]).

CI also runs npm run ui:build (tsc -b && vite build), where Tailwind and CSS errors surface.

Two tests enforce the seams, so read their failure text before anything else:

  • tests/mock.test.js: every invoke("…") in src/ must be registered in Rust's generate_handler! and handled in src/lib/dev-mock.ts, and every registered command must have a caller. Adding a command means all three.
  • tests/interface.test.js: Object.keys of ui/core.js must equal the members of PromptlineCore in src/lib/core.ts. Adding a core function means declaring it there too.

Housekeeping:

  • Remove finished worktrees (git worktree remove): each holds its own node_modules and Rust target/, and the harness leaves a lock on the ones it created. eslint.config.mjs ignores .claude/, so a stale worktree no longer fails npm run lint (it did until ac36903, 2026-10-03); npx eslint src is still the quick check of the app alone.
  • History was rewritten once, on 2026-10-29: every superseded version of docs/screenshots/*, docs/clip/* and docs/og.png was replaced by the current blob (the pack went from about 99 MiB to 8), so every commit since 2026-09-24 has a new SHA. A clone or worktree made before that date must be re-cloned; SHAs quoted in docs or notes before it no longer resolve. The tags were re-pointed and the releases kept their assets. Harness clones take --filter=blob:none to skip the media.
  • Line endings: the index is LF (core.autocrlf=true), working copies are mixed. Run unix2dos on the files you touch, and only those. Scripted edits should normalise \r\n before matching, or they silently miss. Any cargo run (cargo add, a build) rewrites src-tauri/Cargo.toml as LF, which shows as a phantom modification and blocks git merge: git checkout -- src-tauri/Cargo.toml when the diff is only that.
  • Write multi-line edit scripts to a file with the Write tool and run them; a Python heredoc with quotes inside a Bash call trips the tool's parser.
  • Node 24 (npm 11) is the supported floor, for CI and the maintainer alike (.nvmrc and engines in package.json say so), so the npm 10 versus 11 lock mismatch is gone. One hole remains, seen again on 2026-10-29: on Windows, npm update --package-lock-only drops the nested @emnapi/* entries that @tailwindcss/oxide-wasm32-wasi declares, and even npm 11's own npm ci then refuses the lock ("Missing: @emnapi/…"). After any lock change, run npm ci locally before committing; if it fails that way, copy the vanished entries back from the HEAD lock with a script (the 2026-10-29 deps commit did). A plain npm update can also die in reify with EPERM here; lock-only plus npm ci is the recipe that works. Diff the lock against HEAD after adding a dependency: only the new packages should appear.

Verifying UI changes

Look at the change running, not just the diff. The Playwright suite (npm run test:e2e, above) is the first stop: extend it for the behaviour you changed, and it walks both windows for you. Then there are two ways to look, and the first is usually enough.

1. Browser with the fake backend — layout, navigation, menus, keyboard, anything the UI decides on its own.

npx vite --port 5175 --strictPort   # 5173 is often held by another session

Open http://localhost:5175/?mock (manager) or /popup.html?mock (popup); ?mock=empty starts with no prompts. src/lib/dev-mock.ts installs a fake window.__TAURI_INTERNALS__ before the app renders, seeded from packs/*.json plus a small grouped pack, and exposes window.__mock: calls (every invoke with its args), clipboard (settable), emit(event, payload) for backend events such as edit-prompt, library, and pasteResult, update, files (what Generate made), autostart and fail (a set of command names that reject). ?mock=library-error is an upgraded install whose library can't be read; ?mock=first is a first launch, with the first-run banner up, and ?mock=first-off the same with Start with Windows off. Each page has its own in-memory store; a reload starts over. Unknown commands resolve to null and log [mock] unhandled command …. When you add a Tauri command the UI depends on, add it to the mock too.

With the Playwright MCP, browser_run_code_unsafe runs in the browser sandbox: there is no require/fs. Navigate to the ?mock URL and assert through window.__mock. Screenshots at the real window sizes: manager 1000×800, popup 400×600. When Playwright's profile is locked by another session, the Chrome DevTools MCP does the same job (new_page, take_snapshot for the a11y tree, evaluate_script, take_screenshot, resize_page); its resize_page refuses widths under about 500 px, so check the popup's 320×280 minimum with viewport emulation instead. Parallel sessions each take their own port (5175–5178 have been used); stop the server and close your pages when done.

What the mock can't show: real pasting, the global hotkey, window show/hide and focus, file dialogs, and anything Rust does to the payload (paste_snippet receives {clipboard} unexpanded; Rust substitutes it).

2. The real app over CDP — for those.

  • Stop the installed app first (%LOCALAPPDATA%\Promptline\promptline.exe): it shares the WebView2 profile, and a second instance with other browser args never opens the debug port. Restart it detached with Start-Process when done.
  • Back up %APPDATA%\io.github.bekalpaslan.promptline first and restore it after.
  • Run npm run ui:dev (port 5173), then launch src-tauri/target/debug/promptline.exe with WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS=--remote-debugging-port=9223 from a background Bash call (the PowerShell tool kills the child when the call ends). http://127.0.0.1:9223/json lists both pages.
  • Anything gated on bundle_type() (the updater's installer, Start with Windows on a fresh install) needs the exe from inside the installer: the bundler patches target/release/promptline.exe, then puts it back, so that file reads as unknown, like a debug build. 7z e the setup exe.
  • The document is never focused under CDP: focus()/blur() fire nothing, so dispatch focusout. Ctrl+Shift+V is taken by another tool on this machine; test hotkeys on a spare combination and restore the config.

Working in parallel

The 2026-09-22 audit fixes ran as four agents at once, one per file ownership area (Rust; manager; popup and core; docs and release), each in its own worktree branch, merged by the orchestrator. It worked; what made it work:

  • Own files, not topics. Give each agent a file list and forbid the rest. Where two areas meet (a new command's return value, an event's payload), write the contract into both prompts up front so each side builds against it; the popup and Rust agents did this for "copied" and paste-failed without talking.
  • Worktrees start stale. The harness has created agent worktrees several commits behind master. Tell every agent to run git merge --ff-only master (or git reset --hard master if it has no commits) before touching anything. A worktree has no node_modules and an empty target/: budget npm ci and a full Rust build.
  • BEHAVIOR.md is the merge conflict. Each agent edits only its own sections; the orchestrator resolves the rest by keeping both sides. The tracker is never edited by agents (see Where things are written down); they report resolutions in the tracker's format and the orchestrator pastes them in.
  • Finish the tree. After merging, git worktree remove --force every agent worktree (unlock first if the harness left a lock), delete the branches, then run the seven checks from the main checkout. Lint ignores .claude/, where the harness puts them, but still walks worktrees made anywhere else, so it can't pass before those are gone.
  • Sequential when files collide. A wave that touches lib.rs and one that splits it cannot run together; the split ran last, alone.

Small fixes across many files (call-site swaps, plurals) are faster done directly than delegated.

Releasing

Releases are GitHub releases carrying the two Windows installers, built locally. Only on the user's say-so; each step below is one they've approved. The installers job in ci.yml also builds both on a v* tag and uploads them as workflow artefacts; it does not create the release and the local build is still what ships.

  1. Everything is merged to master, pushed, and CI is green on it (gh run watch <id> --exit-status; the run id from gh run list --branch master --limit 3). Don't tag over a red or running CI. The bump commit and the local build can proceed while that first run is still going; only the tag waits.
  2. Bump the version, a patch step unless told otherwise, in all five places, as one commit titled Bump to X.Y.Z:
    • package.json
    • package-lock.json: twice, the root "version" and packages[""] (missing it cost a separate sync commit in 0.2.7)
    • src-tauri/Cargo.toml
    • src-tauri/Cargo.lock: only the name = "promptline" entry. A blanket replace hits other crates at the same version.
    • src-tauri/tauri.conf.json
  3. The signed build, run by the human in their own PowerShell because the updater key's password lives in their password manager, never in this session, with SimplySign Desktop logged in (custody below): $env:TAURI_SIGNING_PRIVATE_KEY = "$env:USERPROFILE\.tauri\promptline-updater.key"; $env:TAURI_SIGNING_PRIVATE_KEY_PASSWORD = [Net.NetworkCredential]::new('', (Read-Host -AsSecureString 'Updater key password')).Password; npm run build (tauri build, several minutes; run it in the background). It writes src-tauri/target/release/bundle/nsis/Promptline_X.Y.Z_x64-setup.exe and …/bundle/msi/Promptline_X.Y.Z_x64_en-US.msi, and now also Promptline_X.Y.Z_x64-setup.exe.sig and Promptline_X.Y.Z_x64_en-US.msi.sig beside them. Without the key set, the build fails; npm run build:unsigned builds without it and is never for a release. Get-AuthenticodeSignature on both installers must read Valid with the Certum signer before tagging.
  4. git tag -a vX.Y.Z -m "Promptline X.Y.Z", then push master and the tag.
  5. gh release create vX.Y.Z --title "Promptline X.Y.Z" --notes-file <notes> --latest with both installers and three byte copies: the setup exe as Promptline-setup.exe (the website's Download button links to releases/latest/download/Promptline-setup.exe; without the copy it 404s) and as Promptline_X.Y.Z_x64-update.exe, the msi as Promptline_X.Y.Z_x64-update.msi (the feed's urls, and nothing else links them, so their downloads count the updates copies took). Check with gh release list (gh release view has no "latest" field), and confirm the five assets landed with gh release view vX.Y.Z --json assets --jq '.assets[] | "\(.digest) \(.name)"': each copy shows its installer's digest.
  6. The feed, after the release: node scripts/latest-json.mjs --notes <notes> (the same notes file as step 5) reads the .sig files from step 3 and writes site/latest.json. It refuses a .sig that doesn't name the version, which requireSignedVersion would fail at Install; tauri build writes it in, and anything signed by hand needs tauri signer sign --app-version X.Y.Z. Before committing, every url the feed names must be an asset of the release, read from gh release view vX.Y.Z --json assets and not fetched: even a HEAD on an asset counts as a download, and these two counts are "kept". Commit it alone as Site: update feed for X.Y.Z, push master, wait for the Pages run (gh run list --workflow pages.yml --limit 1; a cancelled run leaves the old feed live, so gh run rerun <id>), then curl -s https://promptline.cc/latest.json shows the new version (Pages caches up to 10 minutes). Why after: the feed must never point at a release or asset that doesn't exist yet, and its urls are the versioned releases/download/vX.Y.Z/… ones, never latest/download (same reason as winget), naming the -update copies.
  7. The package managers, once curl -s https://promptline.cc/latest.json shows X.Y.Z. Both point at the versioned setup exe, never latest/download, for the same reason as the feed, and both hash the file on the release rather than a local build. Run from the maintainer's PowerShell with their own GitHub login; no token is stored in either repo.
    • winget (AlpaslanBek.Promptline, moniker promptline). The package merged upstream on 2026-11-04 at 0.2.27 (microsoft/winget-pkgs#441945), so each release is one komac update (winget install RussellBanks.Komac once, winget upgrade before each run because the repository retires old manifest schemas; if it isn't on PATH in a fresh shell, its exe is at %LOCALAPPDATA%\Programs\Komac\bin\komac.exe): $env:GITHUB_TOKEN = gh auth token; komac update AlpaslanBek.Promptline --version X.Y.Z --urls https://github.com/bekalpaslan/promptline/releases/download/vX.Y.Z/Promptline_X.Y.Z_x64-setup.exe --release-notes-url https://github.com/bekalpaslan/promptline/releases/tag/vX.Y.Z --submit. komac downloads the exe, hashes it, carries the rest of the manifest over from the last version and opens the PR on microsoft/winget-pkgs from the maintainer's fork (gh repo fork microsoft/winget-pkgs --clone=false once, if it doesn't exist yet). Nothing else waits on winget. A CLA-bot comment needs the maintainer's own @microsoft-github-policy-service agree reply before validation runs; a manifest-only validation error is fixed by pushing a corrected file to the PR's branch and commenting @wingetbot run.
    • Scoop (bekalpaslan/scoop-bucket, checked out beside this repo as ..\scoop-bucket): & "$(scoop prefix scoop)\bin\checkver.ps1" -App promptline -Dir ..\scoop-bucket\bucket -Update reads the version from the feed and rewrites version, url and hash (it downloads the exe to hash it); then in ..\scoop-bucket, git commit -am "promptline: Update to version X.Y.Z" and git push. Scoop users get it on their next scoop update; scoop update promptline runs the manifest's uninstaller script during the bump, but its $cmd -eq 'uninstall' guard skips the real removal, so the data folder is never touched.
  8. The post on X, once the feed is live: node scripts/post-x.mjs --notes <notes> --dry-run (the same notes file again) prints the post, the notes' lead paragraph without its "Builds on" sentence, then Promptline X.Y.Z: <release page>, and its weighted length. Read it; if it needs other words, write them to a file and pass --text <file> instead of --notes. Then the same command without --dry-run, with the four X_* variables set (custody below) in the human's own PowerShell, like the signed build. When the keys are new, node scripts/post-x.mjs --whoami first: it signs a read of the account behind them and prints its handle, so a wrong or read-only key fails there and not on the post. The script checks that the release page answers 200 before it posts, so it can't announce a tag that isn't there, and prints the post's url on success. Each post costs $0.20 (X's pay-per-use price for a post carrying a url, 2026-09), paid from credits bought in the developer console; there is no free tier. Why after the feed: the post is the one step that reaches people, so everything it points at (the release, the installers, the update) is already live.
  9. If windows, commands, events or storage changed since the last map refresh, refresh the architecture map against the tagged commit (its own commit, pushed after).

Signing key custody. The private key is %USERPROFILE%\.tauri\promptline-updater.key, encrypted with a password; both are in the maintainer's password manager, never in the repo or in GitHub secrets until CI builds what ships (the updater signature has to cover the code-signed installer, so CI signs only once it produces that binary). The public key is in tauri.conf.json plugins.updater.pubkey and must never change once a release carries it: every installed copy trusts only that key, and a new one strands every install that's already out.

Code-signing certificate custody. A Certum Open Source Code Signing certificate in the cloud, RSA 4096, issued to the maintainer on 2026-11-05 and valid until 2027-11-05: renew before then, and put the new thumbprint in tauri.conf.json bundle.windows.certificateThumbprint. A renewal changes the thumbprint and nothing an installed copy trusts, since the updater key is separate. The private key stays in Certum's SimplySign cloud; SimplySign Desktop exposes it in CurrentUser\My while logged in with a one-time code from the maintainer's phone, and tauri build signs through signtool, timestamped by http://time.certum.pl (the app, the NSIS plug-ins and uninstaller, both installers; the updater signature comes after, over the signed bytes, checked on 2026-11-05). Both unsigned paths clear the thumbprint: tauri.unsigned.conf.json for CI and build:unsigned, and scripts/update-trial.mjs, so a throwaway build never carries the name.

X credentials custody. Step 8 reads X_API_KEY, X_API_SECRET, X_ACCESS_TOKEN and X_ACCESS_SECRET: the OAuth 1.0a keys of the maintainer's app in the X developer portal, generated with Read and write permission for the account that posts. They live in the password manager, like the updater key's password, and are set only in the shell that runs the step, never in the repo, a .env, or GitHub secrets (the post is a human's step, not CI's, for the same reason the release is). OAuth 1.0a rather than 2.0 because its tokens don't expire, so the step stays one command with no login flow. Regenerate them in the portal if they ever land in a log; --dry-run never reads them.

Release notes, as in every release since 0.2.3 (gh release view v0.2.7): one lead sentence linking the previous release, then a ### section per area in the user's terms (what they see and press, not the code), a behaviour change that could surprise an existing library called out in its bullet — including any release that changes what the app sends over the network, in its own bullet — and this closing section with the version filled in:

### Install

`Promptline_X.Y.Z_x64-setup.exe` (NSIS) or `Promptline_X.Y.Z_x64_en-US.msi`.
Signed, so Windows names the publisher. SmartScreen can still warn while a
new release builds its reputation: *More info → Run anyway*.
Your prompts, packs and settings carry over untouched.

The first release carrying the updater says, in its own bullet, that it is the last one to install by hand, and that the daily check is on for upgraded installs too (no pin, like the hotkey's), switchable under Settings → About.

Conventions

  • Commit subjects are sentence case, often prefixed with the surface (Manager: …, Popup: …, Rust: …, Core: …). The body says what changed and why, in prose.
  • Branch off master for work (feat/…, fix/…, chore/…).
  • Logic that can be pure goes into ui/core.js with a node --test case named after the behaviour or the finding that motivated it; components call it. The audit moved a dozen such helpers out of components; don't put new ones back.
  • One rule per concept, in core: normalizeTag for tags, plural for counts, DRAFT_TITLE / isEmptyDraft for an untouched draft, resolveTheme for the theme, defaultPackFor for where a new prompt goes. Grep for the helper before writing an inline version.
  • In the manager, any write from a closure that outlives its render (context-menu actions, Undo toasts, anything after an await) passes persist an updater, never the render's array; deletes go through deleteWithUndo. Rust writes are intent-level commands (add_pack, set_pack_locked, update_snippet…); only bulk operations send the list, through save_snippets and its revision check.
  • Names the user wrote (packs, groups, prompt titles) are shown as typed; uppercase is for the app's own section labels (name-label vs section-label).
  • The sidebar is the library (search, Display, New, the tree) plus its foot (the Settings gear); the bar above the pane is the open prompt's crumb line; appearance choices live in Settings.
  • Every Tauri command the webview can call takes no path it hasn't been given by Rust (read_pack_file, show_in_folder refuse paths outside the data folder; open_data_dir takes none).

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.