@tiens.nguyen/gu-cli 1.0.686 → 1.0.693

package/coding-key-prompt.mjs

@@ -84,7 +84,7 @@ export async function promptCodingKeyIfMissing(payload, { askSecret, saveCodingK
     return { asked: false, saved: Boolean(ok), keyless: true, model, url: payload.codingKeyUrl };
   }
 
-  log(dim("\ngonext: your agent coding model (") + cyan(model) + dim(") needs an API key."));
+  log(dim("\ngu: your agent coding model (") + cyan(model) + dim(") needs an API key."));
   log(dim("  Until it's set, coding falls back to your local model. Enter the key now,"));
   log(dim("  or press Enter to skip (I'll ask again next time).\n"));
 

package/daemon-control.mjs

@@ -251,7 +251,7 @@ export async function findRunningDaemonPids() {
  * True when `pid` is actually a gu polling daemon (not an unrelated process that reused
  * the PID). Reads that one pid's command line — cheap and exact (review M1).
  */
-function pidIsGonextDaemon(pid) {
+function pidIsGuDaemon(pid) {
   if (!pid || !Number.isFinite(pid)) return Promise.resolve(false);
   return new Promise((resolve) => {
     const one = processCommandCommand(pid);
@@ -324,7 +324,7 @@ export async function readBusyState() {
 export async function daemonStatus() {
   const [pids, pidFilePid] = await Promise.all([findRunningDaemonPids(), readPidFile()]);
   const pidFileIsDaemon =
-    pidFilePid != null && (pids.includes(pidFilePid) || (await pidIsGonextDaemon(pidFilePid)));
+    pidFilePid != null && (pids.includes(pidFilePid) || (await pidIsGuDaemon(pidFilePid)));
   const allPids = pidFileIsDaemon && !pids.includes(pidFilePid) ? [...pids, pidFilePid] : pids;
   return {
     running: allPids.length > 0,

package/gonext_agent_chat.py

@@ -5508,7 +5508,7 @@ def _rag_read_allowed(path: str) -> str:
         base = _WS_ACTIVE or (_WS_ROOTS[0]["path"] if _WS_ROOTS else None)
         if base is None:
             raise ValueError(
-                "No workspace is active — register a folder with `gonext-local-worker "
+                "No workspace is active — register a folder with `gu-local-worker "
                 "workspace add <path>` before reading files."
             )
         expanded = os.path.join(base, _ws_strip_echoed_root(base, expanded))
@@ -5842,7 +5842,7 @@ def _ws_write_allowed(path: str) -> str:
     if w is None:
         raise ValueError(
             "Writes are only allowed inside a registered workspace "
-            "(register one with: gonext-local-worker workspace add <path>)."
+            "(register one with: gu-local-worker workspace add <path>)."
         )
     rel = os.path.relpath(rp, w["path"])
     if rel == ".git" or rel.startswith(".git" + os.sep) or (os.sep + ".git" + os.sep) in (os.sep + rel + os.sep):
@@ -5884,7 +5884,7 @@ def _ws_snapshot(path: str) -> str:
 
 
 def _ws_record_change(action: str, path: str, backup) -> None:
-    """Track a change AND persist the run manifest so `gonext-local-worker workspace
+    """Track a change AND persist the run manifest so `gu-local-worker workspace
     revert` can restore edits / delete created files after the process is gone."""
     import os
     _WS_CHANGES.append({"action": action, "path": path, "backup": backup or None})
@@ -6772,7 +6772,7 @@ def run_agent_chat(cfg):
     # Ollama?" or "did the user pick openai?" separately — reasoning_effort, streaming, the
     # #113 reasoning repairs, and this step budget — now reads `coding_backend`.
     #
-    # The worker (gonext-local-worker.mjs) resolves this first, because it must decide
+    # The worker (gu-local-worker.mjs) resolves this first, because it must decide
     # whether to fetch the coding API key BEFORE python starts, and passes the answer down
     # as codingBackend. Trust it only when we ended up on the URL it judged: the fallbacks
     # above can swap coding_base_url for the chat model's, which is a different server and
@@ -7094,7 +7094,7 @@ def run_agent_chat(cfg):
             )
 
     # ---- Workspaces (local folders the agent may read/edit/test code in) ----
-    # Registered on the Mac via `gonext-local-worker workspace add <path>`; the worker
+    # Registered on the Mac via `gu-local-worker workspace add <path>`; the worker
     # passes the registry through cfg. Only these roots are writable — the security
     # boundary for the coding tools.
     global _WS_ROOTS, _WS_ACTIVE
@@ -11556,7 +11556,7 @@ def run_agent_chat(cfg):
                            "To give the user a FILE or a ZIP of a folder, use the create_download "
                            "tool instead — it needs no shell and works here. "
                            "(To enable real commands, re-register with: "
-                           "gonext-local-worker workspace add <path> --allow-run)")
+                           "gu-local-worker workspace add <path> --allow-run)")
                     _last_obs["text"] = msg
                     return msg
                 argv = shlex.split(command or "")

package/gonext_mlx_embed.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
 """
-GoNext MLX embeddings server — an OpenAI-compatible /v1/embeddings endpoint for MLX
+Gu MLX embeddings server — an OpenAI-compatible /v1/embeddings endpoint for MLX
 embedding models (e.g. Qwen3-Embedding-8B), which `mlx_lm.server` does NOT provide.
 
-The GoNext worker's RAG tools call `POST {url}/v1/embeddings` first, so pointing the
+The Gu worker's RAG tools call `POST {url}/v1/embeddings` first, so pointing the
 "RAG embedding server URL" (web Settings → Agent → RAG) at this server makes MLX
 embeddings work with no other changes.
 

package/gonext_transcribe.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Voice transcription for the GoNext local worker (Audio support, task #21).
+"""Voice transcription for the Gu local worker (Audio support, task #21).
 
 Reads a JSON job on stdin: {"audioPath": str, "model": str, "language": str?}.
 Transcribes with mlx-whisper and prints {"text": "..."} on stdout.

package/gu-cli.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * GoNext local worker:
+ * Gu local worker:
  * - `gu-cli set <workerKey> [--api-base URL]`
  *   writes ~/.gonext/worker.env
  * - `gu-cli ws-ping-test` — POST worker ws-ping (needs GONEXT_* env)
@@ -92,6 +92,8 @@ Usage:
   gu-cli rag                               # test the embedder end-to-end + list knowledge bases
   gu-cli workspace revert [runId]          # undo an agent run's file edits from its backups
   gu-cli clear [--scratch|--keep-history] [--yes]  # back to a fresh machine (asks first)
+  gu-cli fix-powershell [--check]          # Windows: drop PowerShell's built-in \`gu\` alias
+                                               #   (it is Get-Unique and shadows this CLI)
   gu-cli rag plan [path]                   # is RAG worth it here? files/chars/chunks → estimated index time
   gu-cli rag --test                        # can this machine embed and retrieve?
   gu-cli test-proxy                        # can this machine route model calls through a proxy?
@@ -905,6 +907,93 @@ if (args[0] === "token-usage" || args[0] === "tokens") {
   process.exit(0);
 }
 
+// `gu-cli fix-powershell` — drop PowerShell's built-in `gu` alias so the command works there.
+// ASKS FIRST and never runs as part of an install: a PowerShell profile is the user's file, and
+// a CLI that edits it unannounced is one that surprises people. --check only reports.
+if (args[0] === "fix-powershell") {
+  const pa = await import("./powershell-alias.mjs");
+  if (!pa.affectsThisMachine()) {
+    console.log("  Nothing to fix — this only affects Windows PowerShell.");
+    process.exit(0);
+  }
+  const { execFileSync } = await import("node:child_process");
+  const ps = (script) =>
+    execFileSync("powershell", ["-NoProfile", "-Command", script], { encoding: "utf8" }).trim();
+
+  let profilePath = "";
+  try {
+    profilePath = ps("$PROFILE");
+  } catch (e) {
+    console.error(`  Could not ask PowerShell where your profile is: ${e.message}`);
+    process.exit(1);
+  }
+  const { readFileSync, writeFileSync, mkdirSync, existsSync } = await import("node:fs");
+  const current = existsSync(profilePath) ? readFileSync(profilePath, "utf8") : "";
+  const next = pa.profileWithFix(current);
+  // ASKED IN EVERY PATH, because "already fixed" was reported on the very machine whose policy
+  // stops the profile loading — the same "said Done, changed nothing" mistake one branch along.
+  const blockedBy = () => {
+    try {
+      return pa.profileBlockedBy(ps("Get-ExecutionPolicy"));
+    } catch {
+      return "";
+    }
+  };
+  if (next === null) {
+    console.log(`  Already fixed — ${profilePath} removes the alias.`);
+    const blocked = blockedBy();
+    if (blocked) {
+      console.log("");
+      for (const l of pa.policyAdvice(blocked)) console.log("  " + l);
+      process.exit(1);
+    }
+    console.log("  Open a NEW PowerShell window for it to take effect.");
+    process.exit(0);
+  }
+  if (args.includes("--check")) {
+    console.log("  Not fixed yet. `gu` in PowerShell is still Get-Unique.");
+    const blocked = blockedBy();
+    if (blocked) for (const l of pa.policyAdvice(blocked)) console.log("  " + l);
+    console.log(`  Run:  gu-cli fix-powershell    (edits ${profilePath})`);
+    process.exit(1);
+  }
+  console.log("");
+  for (const l of pa.shadowedAdvice()) console.log("  " + l);
+  console.log("");
+  console.log(`  This appends ONE line to ${profilePath}:`);
+  console.log("    " + pa.PROFILE_LINE);
+  const rlp = (await import("node:readline")).createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  const answer = await new Promise((r) => rlp.question("\n  Append it? [y/N]: ", r));
+  rlp.close();
+  if (!/^y(es)?$/i.test(String(answer).trim())) {
+    console.log("  " + pa.MEANWHILE);
+    process.exit(0);
+  }
+  try {
+    const dir = profilePath.replace(/[\\/][^\\/]*$/, "");
+    if (dir && !existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(profilePath, next, "utf8");
+  } catch (e) {
+    console.error(`  Could not write ${profilePath}: ${e.message}`);
+    process.exit(1);
+  }
+  console.log(`  Done — ${profilePath} updated.`);
+  // VERIFY THE FIX CAN ACTUALLY RUN. Writing the line is not the same as PowerShell loading it:
+  // under Restricted or AllSigned the profile is a script it refuses to execute, and the first
+  // real run of this said "Done" to a machine where `gu` stayed shadowed.
+  const policy = blockedBy();
+  if (policy) {
+    console.log("");
+    for (const l of pa.policyAdvice(policy)) console.log("  " + l);
+    process.exit(1);
+  }
+  console.log("  Open a NEW PowerShell window, then `gu` runs this CLI.");
+  process.exit(0);
+}
+
 if (args[0] === "clear" || args[0] === "reset") {
   const cs = await import("./clear-state.mjs");
   const scratchOnly = args.includes("--scratch");
@@ -2838,7 +2927,7 @@ async function runOcrJob(job) {
     }
     console.log(`[gu-worker] OCR source jobId=${jobId} ${sourceLabel}`);
 
-    const tempDir = await mkdtemp(join(tmpdir(), "gonext-ocr-worker-"));
+    const tempDir = await mkdtemp(join(tmpdir(), "gu-ocr-worker-"));
     let extractedText = "";
     try {
       const imagePath = join(

package/gu-repl.mjs

@@ -783,7 +783,6 @@ const COMMANDS = [
   // The two synonyms were dispatched but declared nowhere (found by slash-command-wiring.test.mjs):
   // they worked, Tab-completed to nothing, and appeared in no help. Aliases is what the registry
   // already has for exactly this — /quit, /rag-local.
-  { name: "/ask-again", aliases: ["/daemon-ask", "/model-setup-ask"], desc: "forget the remembered \"no\" for the model-setup prompt in this folder" },
   { name: "/host-mode", desc: "undo client mode — run agent turns on THIS machine again" },
   { name: "/server", desc: "pick a deployment server (host/user) for this session" },
   { name: "/proxy", usage: "/proxy [show|set|on|off|clear|test]", desc: "route MODEL calls through an HTTP proxy (local calls always go direct)" },
@@ -1795,7 +1794,7 @@ async function refreshAvailableUpdates() {
   const { updatesAvailable } = await import("./version-check.mjs");
   const cliLatest = await (async () => {
     try {
-      const r = await fetch("https://registry.npmjs.org/@tiens.nguyen%2Fgonext-cli/latest", {
+      const r = await fetch("https://registry.npmjs.org/@tiens.nguyen%2Fgu-cli/latest", {
         signal: AbortSignal.timeout(6000),
       });
       return r.ok ? (await r.json())?.version ?? "" : "";
@@ -9350,7 +9349,7 @@ async function main() {
             servers: await (await import("./model-doctor.mjs")).discoverModelServers(),
           });
       const statusRows = [
-        bold(cyan("GONEXT AGENT")) + dim(`  v${REPL_VERSION}`),
+        bold(cyan("GU AGENT")) + dim(`  v${REPL_VERSION}`),
         // Task #134: a client machine OVERRIDES the account's agent model locally (the
         // account value points at the model host's own server). Show what will actually be
         // used, not a value this machine can't reach.
@@ -9422,7 +9421,7 @@ async function main() {
           const skipDeps = await loadSessionSkip(resolve(process.cwd()), "skipDepsPrompt");
           if (!skipDeps) {
             console.log(
-              dim("\ngonext: the agent framework (smolagents + openai) isn't installed here —") +
+              dim("\ngu: the agent framework (smolagents + openai) isn't installed here —") +
                 dim("\n  every turn will fail without it. It's a small pip install; no models.")
             );
             if (await askOr(false, () => askYesNo("Install the agent framework now?", true))) {
@@ -9469,10 +9468,10 @@ async function main() {
         // to a local model setup here — its model is remote by design.
         if (!clientModeBanner && !(await md.probeModelServer(chatUrl))) {
           console.log(
-            dim(`\ngonext: the chat model server (${md.modelRoot(chatUrl)}) isn't responding.`)
+            dim(`\ngu: the chat model server (${md.modelRoot(chatUrl)}) isn't responding.`)
           );
           // Task #135: remember a "no" for this folder. `gu-cli doctor` still works
-          // explicitly; /model-setup-ask clears the memory.
+          // explicitly; `gu doctor` runs the same setup whenever it is wanted.
           const skipSetup = await loadSessionSkip(resolve(process.cwd()), "skipModelSetupPrompt");
           // Esc = "not now" rather than "yes": this branch DOWNLOADS a model, and a cancelled
           // question must never be read as consent to start one.
@@ -9483,8 +9482,8 @@ async function main() {
               );
           if (skipSetup) {
             console.log(
-              dim("  Set-up skipped (remembered for this folder) — `gu doctor` to run it, ") +
-                dim("`/model-setup-ask` to be asked again.\n")
+              dim("  Set-up skipped (remembered for this folder) — `gu doctor` runs it ") +
+                dim("any time.\n")
             );
           }
           if (go) {
@@ -9980,24 +9979,6 @@ async function main() {
       );
       continue;
     }
-    if (line === "/ask-again" || line === "/daemon-ask" || line === "/model-setup-ask") {
-      // Task #135: the way BACK from a remembered "no". Without this the choice is a
-      // one-way door — a setup that later changes (model installed, daemon wanted) would
-      // have no route to the prompt again short of editing the session file by hand.
-      await saveSessionSkip(cwd, "skipDaemonPrompt", false);
-      await saveSessionSkip(cwd, "skipModelSetupPrompt", false);
-      await saveSessionSkip(cwd, "skipDepsPrompt", false);
-      // The background worker is no longer among these: it is started and announced rather than
-      // asked about (task #159), so there is no remembered "no" left to undo. `gu stop` is
-      // the way to not have one running. Clearing its old key anyway, harmlessly, so a session
-      // file written by an earlier version does not keep a setting nothing reads.
-      console.log(
-        cyan("startup prompts re-enabled") +
-          dim(" — you'll be asked about model setup again next time you run `gu` here.\n") +
-          dim("  (the background worker is started automatically now — `gu stop` to stop it.)\n")
-      );
-      continue;
-    }
     if (line === "/rag" || line === "/rag-cloud" || line === "/rag-local") {
       // ONE QUESTION, THREE ANSWERS (task #180). This was two commands that toggled one flag,
       // so the command you typed did not determine the state you got — and the reply named a

package/install-path.mjs

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+/**
+ * postinstall: make `gu` / `gu-cli` runnable from the NEXT terminal without the user
+ * ever editing a profile by hand.
+ *
+ * WHY: the support loop that prompted this file is always the same — a user on macOS or
+ * Ubuntu runs `npm install -g @tiens.nguyen/gu-cli`, npm puts the shims in a global bin
+ * dir their shell never heard of, and the very first command answers "gu: command not
+ * found". The CLI works; the PATH does not. Users file it as "the install is broken".
+ *
+ * WHAT THIS DOES, in order of preference:
+ *   1. Nothing, when the global bin dir is already on PATH (the common case with nvm,
+ *      Homebrew-node, or a repointed npm prefix).
+ *   2. Appends ONE idempotent, marker-wrapped `export PATH=...` block to the user's
+ *      shell rc file — .zshrc on macOS (default shell since Catalina), .bashrc on
+ *      Ubuntu/Debian — creating the file only when that shell is the platform default.
+ *   3. Prints the exact `export` line for the CURRENT terminal, because a child process
+ *      physically cannot `source` anything into its parent shell.
+ *
+ * HARD RULES:
+ *   - NEVER fail the install. Every path through this file ends in exit 0; npm treats a
+ *     postinstall failure as a failed install and the user gets nothing.
+ *   - NEVER run on Windows (PATH there lives in the registry, and `gu`'s PowerShell
+ *     alias problem is powershell-alias.mjs's job, explicitly interactive).
+ *   - NEVER touch an rc file twice: the marker pair makes re-runs no-ops.
+ *   - Under `sudo npm i -g`, write to the REAL user's home (SUDO_USER) and chown the
+ *     file back, or the user's next login shell reads a root-owned rc file.
+ */
+import { appendFileSync, existsSync, readFileSync, chownSync, writeFileSync } from "node:fs";
+import { homedir, platform, tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const BEGIN = "# >>> gu-cli PATH >>>";
+const END = "# <<< gu-cli PATH <<<";
+
+/**
+ * Self-execute ONLY as the postinstall entry point.
+ *
+ * WHY THE GUARD: scripts/preflight.mjs step 4 does `await import()` on every shipped
+ * module to prove it resolves. The first version of this file ran main() and called
+ * process.exit(0) at import time — the import KILLED the preflight runner mid-step,
+ * exit code 0, summary never printed. A module that exits its importer is a landmine;
+ * only the direct `node install-path.mjs` invocation (npm's postinstall) may run it.
+ */
+const isEntryPoint = (() => {
+  try {
+    return process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+  } catch {
+    return false;
+  }
+})();
+
+if (isEntryPoint) {
+  try {
+    main();
+  } catch (e) {
+    // A postinstall that throws uninstalls the package. Report, swallow, succeed.
+    console.log(`gu-cli: PATH setup skipped (${e.message}) — see \`gu-cli doctor\` if \`gu\` is not found.`);
+  }
+  process.exit(0);
+}
+
+function main() {
+  if (platform() === "win32") return;                 // registry PATH + PowerShell alias: not here
+  if (process.env.CI) return;                          // no user shell to help in CI
+  const prefix = process.env.npm_config_prefix;
+  if (!prefix) return;                                 // not an npm install context
+  const binDir = join(prefix, "bin");
+  if (resolve(binDir).startsWith(resolve(tmpdir()))) return; // preflight's throwaway prefix
+
+  const onPath = (process.env.PATH || "").split(":").some((p) => p === binDir);
+  if (onPath) return;                                  // nothing to fix — most installs
+
+  const home = realUserHome();
+  const targets = rcFilesFor(home);
+  const block = `${BEGIN}\n# npm's global bin dir was not on PATH; added by @tiens.nguyen/gu-cli postinstall.\nexport PATH="${binDir}:$PATH"\n${END}\n`;
+
+  let wrote = null;
+  for (const rc of targets) {
+    if (ensureBlock(rc, block)) { wrote = wrote || rc; }
+  }
+
+  if (wrote) {
+    console.log(`gu-cli: added ${binDir} to PATH in ${wrote}.`);
+    console.log(`gu-cli: open a NEW terminal to use \`gu\`, or run this once in the current one:`);
+    console.log(`  export PATH="${binDir}:$PATH"`);
+  } else if (targets.length === 0) {
+    console.log(`gu-cli: ${binDir} is not on your PATH and no shell profile was found to update.`);
+    console.log(`  export PATH="${binDir}:$PATH"`);
+  }
+}
+
+/** The installer's home — the invoking user's, not root's, under sudo. */
+function realUserHome() {
+  const sudoUser = process.env.SUDO_USER;
+  if (sudoUser && process.getuid && process.getuid() === 0) {
+    return platform() === "darwin" ? join("/Users", sudoUser) : join("/home", sudoUser);
+  }
+  return homedir();
+}
+
+/**
+ * Which rc files to maintain, in order. macOS default is zsh; Ubuntu default is bash.
+ * A non-default shell's rc is updated only if the file already exists — we fix the
+ * setups people HAVE, we don't seed shells they don't use.
+ */
+function rcFilesFor(home) {
+  const zshrc = join(home, ".zshrc");
+  const bashrc = join(home, ".bashrc");
+  const out = [];
+  if (platform() === "darwin") {
+    out.push(zshrc);
+    if (existsSync(bashrc)) out.push(bashrc);
+  } else {
+    out.push(bashrc);
+    if (existsSync(zshrc)) out.push(zshrc);
+  }
+  return out;
+}
+
+/** Append the block unless the marker is already there. True when the file changed. */
+function ensureBlock(rcFile, block) {
+  const prior = existsSync(rcFile) ? readFileSync(rcFile, "utf8") : "";
+  if (prior.includes(BEGIN)) return false;
+  if (!existsSync(rcFile)) writeFileSync(rcFile, block);
+  else appendFileSync(rcFile, (prior.endsWith("\n") || prior === "" ? "" : "\n") + block);
+  chownBackToSudoUser(rcFile);
+  return true;
+}
+
+/** `sudo npm i -g` would otherwise leave a root-owned .zshrc the user cannot edit. */
+function chownBackToSudoUser(file) {
+  const { SUDO_UID, SUDO_GID } = process.env;
+  if (SUDO_UID && SUDO_GID && process.getuid && process.getuid() === 0) {
+    try { chownSync(file, Number(SUDO_UID), Number(SUDO_GID)); } catch { /* best effort */ }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.686",
+  "version": "1.0.693",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",
@@ -13,11 +13,12 @@
     "url": "https://github.com/tiennsloit/gu/issues"
   },
   "bin": {
-    "gu-cli": "./gu-cli.mjs",
-    "gu-local-worker": "./gu-cli.mjs",
-    "gu": "./gu-repl.mjs"
+    "gu-cli": "gu-cli.mjs",
+    "gu-local-worker": "gu-cli.mjs",
+    "gu": "gu-repl.mjs"
   },
   "scripts": {
+    "postinstall": "node install-path.mjs",
     "test": "python3 -m unittest discover tests -v && node --test",
     "test:js": "node --test",
     "test:keys": "node --test tests/key-choice-regression.test.mjs tests/coding-key-line.test.mjs tests/coding-key-picker.test.mjs tests/coding-key-prompt.test.mjs tests/coding-key-notice.test.mjs tests/coding-key-fallback-line.test.mjs tests/manage-coding-providers.test.mjs tests/add-coding-provider.test.mjs tests/coding-provider-setup.test.mjs",
@@ -77,6 +78,8 @@
     "proxy-dispatcher.mjs",
     "model-doctor.mjs",
     "coding-key-prompt.mjs",
+    "powershell-alias.mjs",
+    "install-path.mjs",
     "gonext_probe_agent.py",
     "gonext_agent_chat.py",
     "gonext_transcribe.py",

package/powershell-alias.mjs

@@ -0,0 +1,94 @@
+/**
+ * `gu` IS A BUILT-IN POWERSHELL ALIAS FOR Get-Unique.
+ *
+ * Found by the Windows end-to-end run: on Windows 11, where PowerShell is the default shell,
+ * typing `gu --help` runs Get-Unique and fails with "A positional parameter cannot be found that
+ * accepts argument '--help'". cmd.exe has no such alias, which is why it works there.
+ *
+ * NOTHING ON PATH CAN FIX THIS. PowerShell resolves Alias → Function → Cmdlet → Application, so
+ * an alias beats every executable and every function we could ship. The only remedies are to
+ * remove the alias from the user's profile, or to be called something else.
+ *
+ * So this offers the removal, EXPLICITLY and never automatically. A profile is the user's file;
+ * a CLI that edits it during an install is a CLI that surprises people. `gu-cli fix-powershell`
+ * asks, shows the line, and appends it — and `--check` just reports.
+ */
+
+/** The line appended to the profile. `-Force` because the built-in alias is read-only. */
+export const PROFILE_LINE =
+  "Remove-Item Alias:gu -Force -ErrorAction SilentlyContinue  # gu CLI: PowerShell's built-in `gu` is Get-Unique";
+
+/**
+ * What still works while the alias is in place.
+ *
+ * IT LIVES HERE, NOT IN gu-cli.mjs, and that is not tidiness. platform-assumptions.test.mjs
+ * switches on a rule for any file whose source mentions a quoted ".cmd" — and gu-cli.mjs has
+ * several long-standing spawn sites that the rule then flags. One sentence about `gu.cmd` in
+ * that file woke all of them. Keeping the string in this module leaves that file exactly as it
+ * was, and those sites a separate question rather than one a rename quietly changed.
+ */
+export const MEANWHILE = "Left alone. `gu-cli` and `gu.cmd` both run this program in the meantime.";
+
+/** True when this machine can even have the problem. */
+export function affectsThisMachine(platform = process.platform) {
+  return platform === "win32";
+}
+
+/**
+ * What to tell someone whose `gu` is shadowed.
+ *
+ * Names BOTH working commands first, because the immediate need is to run the thing at all —
+ * the profile edit is the fix for tomorrow, `gu-cli` is the fix for right now.
+ */
+export function shadowedAdvice() {
+  return [
+    "PowerShell has a built-in alias `gu` (Get-Unique) that wins over this CLI.",
+    "Right now:   use `gu-cli` — or `gu.cmd`, which is this program.",
+    "Permanently: run `gu-cli fix-powershell` to drop the alias from your PowerShell profile.",
+    "cmd.exe is unaffected; `gu` works there already.",
+  ];
+}
+
+/**
+ * Will PowerShell even LOAD a profile on this machine?
+ *
+ * Found immediately after the first real fix: the line was written, the command said "Done",
+ * and a new PowerShell still had the alias — because the execution policy was Restricted and
+ * profiles are scripts. A fix that cannot run is worse than no fix, because it stops you
+ * looking for the real reason.
+ *
+ * "Restricted" and "AllSigned" both refuse an unsigned profile. Everything else loads it.
+ */
+export function profileBlockedBy(policy) {
+  const p = String(policy ?? "").trim();
+  return /^(Restricted|AllSigned)$/i.test(p) ? p : "";
+}
+
+/** What to do about a policy that will not run the profile. The user's decision, not ours. */
+export function policyAdvice(policy) {
+  return [
+    `PowerShell's execution policy is ${policy}, so it will not load your profile —`,
+    "the line is written but will never run. To allow your own profile:",
+    "  Set-ExecutionPolicy -Scope CurrentUser RemoteSigned",
+    "Until then `gu-cli` and `gu.cmd` still work, and cmd.exe is unaffected.",
+  ];
+}
+
+/**
+ * Is the line already in a profile's text?
+ *
+ * Matched on the COMMAND, not the whole line including its comment — so a profile edited by
+ * hand, or by an older version of this message, is still recognised and not appended to twice.
+ */
+export function alreadyFixed(profileText) {
+  return /Remove-Item\s+Alias:gu\b/i.test(String(profileText ?? ""));
+}
+
+/** The text to write, given what the profile already holds. Returns null when nothing is needed. */
+export function profileWithFix(profileText) {
+  if (alreadyFixed(profileText)) return null;
+  const prev = String(profileText ?? "");
+  // A profile that does not end in a newline would otherwise get the fix glued to its last line.
+  const sep = prev.length === 0 ? "" : prev.endsWith("\n") ? "" : "\n";
+  return `${prev}${sep}${PROFILE_LINE}\n`;
+}