@lovrozagar/grunt 0.6.2 → 0.8.0

package/cli/grunt.mjs

@@ -4,6 +4,15 @@ import path from "node:path"
 import { fileURLToPath } from "node:url"
 import { destAlreadyInited, init, RESERVED_SKILLS, toGruntScriptName } from "./init.mjs"
 import { confirm, isInteractive, select, spinner } from "./prompt.mjs"
+import {
+  PACKAGE_MANAGER_ASK,
+  PACKAGE_MANAGER_OPTIONS,
+  UNKNOWN_PACKAGE_MANAGER,
+  detectPackageManager,
+  isPackageManager,
+  runScriptArgs,
+} from "../scripts/package-manager.mjs"
+import { mapCommand } from "../scripts/folder-map.mjs"
 
 const PKG_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), "..")
 
@@ -12,14 +21,15 @@ const USAGE = `Usage: grunt [command]
 Default (no command): TTY menu; else init — full setup
 
 Commands:
-  init          Full setup: merge SoT, npm install, grunt:rulesync:generate, grunt:sync:globals:apply, grunt:rulesync:check
-  generate      npm run grunt:rulesync:generate
-  check         npm run grunt:rulesync:check
-  sync-globals  npm run grunt:sync:globals (dry-run; --apply to write)
-  purge-mcps    npm run grunt:purge:global-mcps (dry-run; --apply to write)
-  doctor        npm run grunt:doctor
-  setup         npm run grunt:setup — handheld keys/OAuth (speak, listen, google-workspace, browser)
+  init          Full setup: merge SoT, install, grunt:rulesync:generate, grunt:sync:globals:apply, grunt:rulesync:check
+  generate      run grunt:rulesync:generate
+  check         run grunt:rulesync:check
+  sync-globals  run grunt:sync:globals (dry-run; --apply to write)
+  purge-mcps    run grunt:purge:global-mcps (dry-run; --apply to write)
+  doctor        run grunt:doctor
+  setup         run grunt:setup — handheld keys/OAuth (speak, listen, google-workspace, browser)
   upgrade       Re-init: copy owned files, prune retired grunt-owned names, print reserved skills
+  map [dir]     Code-only folder map (git-tracked, no files); dir for depth
   help          Show this help
   version       Print package version
 
@@ -29,6 +39,7 @@ Flags:
   --non-interactive  Same as --yes
   --apply            Write for sync-globals / purge-mcps
   --host <id>        sync-globals host
+  --pm <name>        npm | yarn | pnpm | bun (else lockfile, then how grunt was launched, then ask)
 `
 
 const MENU_OPTIONS = [
@@ -45,26 +56,41 @@ const MENU_OPTIONS = [
 ]
 
 const YES_FLAGS = new Set(["--yes", "-y", "--non-interactive"])
+const NEEDS_PM = new Set([
+  "init",
+  "generate",
+  "check",
+  "sync-globals",
+  "purge-mcps",
+  "doctor",
+  "setup",
+  "upgrade",
+])
 
 function pkgVersion() {
   const pkg = JSON.parse(readFileSync(path.join(PKG_ROOT, "package.json"), "utf8"))
   return pkg.version
 }
 
-function npmRun(script, extra = []) {
-  const args = extra.length ? ["run", script, "--", ...extra] : ["run", script]
-  execFileSync("npm", args, { cwd: process.cwd(), stdio: "inherit" })
+function runScript(pm, script, extra = []) {
+  execFileSync(pm, runScriptArgs(pm, script, extra), { cwd: process.cwd(), stdio: "inherit" })
 }
 
 function hostValueOk(v) {
   return v != null && v !== "" && !String(v).startsWith("-")
 }
 
+function pmValueOk(v) {
+  return v != null && v !== "" && isPackageManager(v)
+}
+
 export function parseArgv(argv) {
   let skipGlobals = false
   let apply = false
   let host
   let hostError = false
+  let pm
+  let pmError = false
   const positionals = []
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i]
@@ -92,9 +118,25 @@ export function parseArgv(argv) {
       if (!hostValueOk(host)) hostError = true
       continue
     }
+    if (a === "--pm") {
+      const v = argv[i + 1]
+      if (!pmValueOk(v)) {
+        pmError = true
+        continue
+      }
+      pm = String(v).toLowerCase()
+      i += 1
+      continue
+    }
+    if (typeof a === "string" && a.startsWith("--pm=")) {
+      pm = a.slice("--pm=".length)
+      if (!pmValueOk(pm)) pmError = true
+      else pm = pm.toLowerCase()
+      continue
+    }
     positionals.push(a)
   }
-  return { cmd: positionals[0], args: positionals.slice(1), skipGlobals, apply, host, hostError }
+  return { cmd: positionals[0], args: positionals.slice(1), skipGlobals, apply, host, hostError, pm, pmError }
 }
 
 function hostExtra(host) {
@@ -111,9 +153,23 @@ function bindSpinner() {
 
 export const APPLY_GLOBALS_CONFIRM = "Apply global prompt optimizations? (recommended)"
 
-async function runInit(cwd, { skipGlobals, interactive }) {
+export async function resolveCliPackageManager({ cwd, env, override, interactive }) {
+  const detected = detectPackageManager({ cwd, env, override })
+  if (detected.manager) return detected.manager
+  if (interactive) {
+    return await select({
+      message: PACKAGE_MANAGER_ASK,
+      options: PACKAGE_MANAGER_OPTIONS,
+    })
+  }
+  process.stdout.write(`${UNKNOWN_PACKAGE_MANAGER}\n`)
+  process.exitCode = 1
+  return null
+}
+
+async function runInit(cwd, { skipGlobals, interactive, packageManager }) {
   if (!interactive) {
-    init(cwd, { skipGlobals })
+    init(cwd, { skipGlobals, packageManager })
     return
   }
   if (destAlreadyInited(cwd)) {
@@ -131,10 +187,11 @@ async function runInit(cwd, { skipGlobals, interactive }) {
     skipGlobals: !applyGlobals,
     applyGlobals,
     onPhase: bindSpinner(),
+    packageManager,
   })
 }
 
-async function dispatch(cmd, flags, interactive) {
+async function dispatch(cmd, flags, interactive, pm) {
   if (cmd === "help" || cmd === "--help" || cmd === "-h") {
     process.stdout.write(USAGE)
     return
@@ -147,38 +204,44 @@ async function dispatch(cmd, flags, interactive) {
     await runInit(process.cwd(), {
       skipGlobals: flags.skipGlobals,
       interactive: interactive && (!cmd || cmd === "init"),
+      packageManager: pm,
     })
     return
   }
   if (cmd === "generate") {
-    npmRun(toGruntScriptName("rulesync:generate"))
+    runScript(pm, toGruntScriptName("rulesync:generate"))
     return
   }
   if (cmd === "check") {
-    npmRun(toGruntScriptName("rulesync:check"))
+    runScript(pm, toGruntScriptName("rulesync:check"))
     return
   }
   if (cmd === "sync-globals") {
     const script = flags.apply ? toGruntScriptName("sync:globals:apply") : toGruntScriptName("sync:globals")
-    npmRun(script, hostExtra(flags.host))
+    runScript(pm, script, hostExtra(flags.host))
     return
   }
   if (cmd === "purge-mcps") {
-    npmRun(flags.apply ? toGruntScriptName("purge:global-mcps:apply") : toGruntScriptName("purge:global-mcps"))
+    runScript(pm, flags.apply ? toGruntScriptName("purge:global-mcps:apply") : toGruntScriptName("purge:global-mcps"))
     return
   }
   if (cmd === "doctor") {
-    npmRun(toGruntScriptName("doctor"))
+    runScript(pm, toGruntScriptName("doctor"))
     return
   }
   if (cmd === "setup") {
-    npmRun(toGruntScriptName("setup"), flags.args)
+    runScript(pm, toGruntScriptName("setup"), flags.args)
+    return
+  }
+  if (cmd === "map") {
+    process.stdout.write(mapCommand(process.cwd(), flags.args[0] || ""))
     return
   }
   if (cmd === "upgrade") {
     await runInit(process.cwd(), {
       skipGlobals: flags.skipGlobals,
       interactive: false,
+      packageManager: pm,
     })
     process.stdout.write(`reserved: ${RESERVED_SKILLS.join(" ")}\n`)
     return
@@ -187,9 +250,13 @@ async function dispatch(cmd, flags, interactive) {
   process.exitCode = 1
 }
 
+function commandNeedsPackageManager(cmd) {
+  return !cmd || NEEDS_PM.has(cmd)
+}
+
 export async function start() {
   const flags = parseArgv(process.argv.slice(2))
-  if (flags.hostError) {
+  if (flags.hostError || flags.pmError) {
     process.stdout.write(USAGE)
     process.exitCode = 1
     return
@@ -205,5 +272,15 @@ export async function start() {
     if (choice === "quit") return
     cmd = choice
   }
-  await dispatch(cmd, flags, interactive)
+  let pm
+  if (commandNeedsPackageManager(cmd)) {
+    pm = await resolveCliPackageManager({
+      cwd: process.cwd(),
+      env: process.env,
+      override: flags.pm,
+      interactive,
+    })
+    if (!pm) return
+  }
+  await dispatch(cmd, flags, interactive, pm)
 }

package/cli/grunt.test.ts

@@ -10,6 +10,8 @@ const toGruntScriptName = vi.hoisted(
   () => (k) => (String(k).startsWith("grunt:") ? k : `grunt:${k}`),
 );
 const execFileSync = vi.hoisted(() => vi.fn());
+const detectPackageManager = vi.hoisted(() => vi.fn());
+const actualDetect = vi.hoisted(() => ({ fn: null as null | ((...args: unknown[]) => unknown) }));
 const isInteractive = vi.hoisted(() => vi.fn(() => false));
 const select = vi.hoisted(() => vi.fn());
 const confirm = vi.hoisted(() => vi.fn());
@@ -17,6 +19,7 @@ const spinner = vi.hoisted(() =>
   vi.fn(() => ({ start: vi.fn(), stop: vi.fn() })),
 );
 const bailIfCancel = vi.hoisted(() => vi.fn((v) => v));
+const mapCommand = vi.hoisted(() => vi.fn((_cwd: string, dir: string) => `map:${dir}\n`));
 
 vi.mock("./init.mjs", () => ({
   init,
@@ -27,6 +30,17 @@ vi.mock("./init.mjs", () => ({
   GRUNT_NPM_PREFIX: "grunt:",
 }));
 vi.mock("node:child_process", () => ({ execFileSync }));
+vi.mock("../scripts/folder-map.mjs", () => ({ mapCommand }));
+vi.mock("../scripts/package-manager.mjs", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../scripts/package-manager.mjs")>();
+  actualDetect.fn = actual.detectPackageManager;
+  detectPackageManager.mockImplementation((...args: unknown[]) =>
+    actual.detectPackageManager(
+      ...(args as Parameters<typeof actual.detectPackageManager>),
+    ),
+  );
+  return { ...actual, detectPackageManager };
+});
 vi.mock("./prompt.mjs", () => ({
   isInteractive,
   select,
@@ -35,6 +49,10 @@ vi.mock("./prompt.mjs", () => ({
   bailIfCancel,
 }));
 
+import {
+  PACKAGE_MANAGER_ASK,
+  UNKNOWN_PACKAGE_MANAGER,
+} from "../scripts/package-manager.mjs";
 import { APPLY_GLOBALS_CONFIRM, parseArgv, start } from "./grunt.mjs";
 
 const USAGE = `Usage: grunt [command]
@@ -42,14 +60,15 @@ const USAGE = `Usage: grunt [command]
 Default (no command): TTY menu; else init — full setup
 
 Commands:
-  init          Full setup: merge SoT, npm install, grunt:rulesync:generate, grunt:sync:globals:apply, grunt:rulesync:check
-  generate      npm run grunt:rulesync:generate
-  check         npm run grunt:rulesync:check
-  sync-globals  npm run grunt:sync:globals (dry-run; --apply to write)
-  purge-mcps    npm run grunt:purge:global-mcps (dry-run; --apply to write)
-  doctor        npm run grunt:doctor
-  setup         npm run grunt:setup — handheld keys/OAuth (speak, listen, google-workspace, browser)
+  init          Full setup: merge SoT, install, grunt:rulesync:generate, grunt:sync:globals:apply, grunt:rulesync:check
+  generate      run grunt:rulesync:generate
+  check         run grunt:rulesync:check
+  sync-globals  run grunt:sync:globals (dry-run; --apply to write)
+  purge-mcps    run grunt:purge:global-mcps (dry-run; --apply to write)
+  doctor        run grunt:doctor
+  setup         run grunt:setup — handheld keys/OAuth (speak, listen, google-workspace, browser)
   upgrade       Re-init: copy owned files, prune retired grunt-owned names, print reserved skills
+  map [dir]     Code-only folder map (git-tracked, no files); dir for depth
   help          Show this help
   version       Print package version
 
@@ -59,6 +78,7 @@ Flags:
   --non-interactive  Same as --yes
   --apply            Write for sync-globals / purge-mcps
   --host <id>        sync-globals host
+  --pm <name>        npm | yarn | pnpm | bun (else lockfile, then how grunt was launched, then ask)
 `;
 
 const pkgRoot = path.join(path.dirname(fileURLToPath(import.meta.url)), "..");
@@ -88,6 +108,10 @@ describe("start", () => {
     shouldAutoSkipGlobals.mockReset();
     shouldAutoSkipGlobals.mockReturnValue(false);
     execFileSync.mockReset();
+    detectPackageManager.mockReset();
+    detectPackageManager.mockImplementation((...args: unknown[]) =>
+      (actualDetect.fn as (...a: unknown[]) => unknown)(...args),
+    );
     isInteractive.mockReset();
     isInteractive.mockReturnValue(false);
     select.mockReset();
@@ -125,7 +149,10 @@ describe("start", () => {
     process.argv = ["node", "grunt"];
     await start();
     expect(init).toHaveBeenCalledOnce();
-    expect(init).toHaveBeenCalledWith(process.cwd(), { skipGlobals: false });
+    expect(init).toHaveBeenCalledWith(process.cwd(), {
+      skipGlobals: false,
+      packageManager: "npm",
+    });
     expect(execFileSync).not.toHaveBeenCalled();
     expect(select).not.toHaveBeenCalled();
   });
@@ -134,7 +161,10 @@ describe("start", () => {
     process.argv = ["node", "grunt", "init"];
     await start();
     expect(init).toHaveBeenCalledOnce();
-    expect(init).toHaveBeenCalledWith(process.cwd(), { skipGlobals: false });
+    expect(init).toHaveBeenCalledWith(process.cwd(), {
+      skipGlobals: false,
+      packageManager: "npm",
+    });
   });
 
   it.each([
@@ -145,7 +175,10 @@ describe("start", () => {
     process.argv = argv;
     await start();
     expect(init).toHaveBeenCalledOnce();
-    expect(init).toHaveBeenCalledWith(process.cwd(), { skipGlobals: true });
+    expect(init).toHaveBeenCalledWith(process.cwd(), {
+      skipGlobals: true,
+      packageManager: "npm",
+    });
   });
 
   it.each(["--yes", "-y", "--non-interactive"])(
@@ -156,7 +189,10 @@ describe("start", () => {
       expect(isInteractive).toHaveBeenCalledOnce();
       expect(select).not.toHaveBeenCalled();
       expect(init).toHaveBeenCalledOnce();
-      expect(init).toHaveBeenCalledWith(process.cwd(), { skipGlobals: false });
+      expect(init).toHaveBeenCalledWith(process.cwd(), {
+        skipGlobals: false,
+        packageManager: "npm",
+      });
     },
   );
 
@@ -280,11 +316,30 @@ describe("start", () => {
     process.argv = ["node", "grunt", "upgrade"];
     await start();
     expect(init).toHaveBeenCalledOnce();
-    expect(init).toHaveBeenCalledWith(process.cwd(), { skipGlobals: false });
+    expect(init).toHaveBeenCalledWith(process.cwd(), {
+      skipGlobals: false,
+      packageManager: "npm",
+    });
     expect(chunks.join("")).toBe("reserved: browser tmp write-plan\n");
     expect(select).not.toHaveBeenCalled();
   });
 
+  it("map prints the folder map without a package manager", async () => {
+    process.argv = ["node", "grunt", "map"];
+    await start();
+    expect(mapCommand).toHaveBeenLastCalledWith(process.cwd(), "");
+    expect(chunks.join("")).toBe("map:\n");
+    expect(detectPackageManager).not.toHaveBeenCalled();
+    expect(execFileSync).not.toHaveBeenCalled();
+  });
+
+  it("map <dir> scopes the folder map", async () => {
+    process.argv = ["node", "grunt", "map", "packages/web"];
+    await start();
+    expect(mapCommand).toHaveBeenLastCalledWith(process.cwd(), "packages/web");
+    expect(chunks.join("")).toBe("map:packages/web\n");
+  });
+
   it("unknown writes usage and exitCode 1", async () => {
     process.argv = ["node", "grunt", "nope"];
     await start();
@@ -408,6 +463,7 @@ describe("start", () => {
       expect.objectContaining({
         skipGlobals: false,
         applyGlobals: true,
+        packageManager: "npm",
         onPhase: expect.any(Function),
       }),
     );
@@ -418,6 +474,84 @@ describe("start", () => {
     expect(spin.stop).toHaveBeenCalledWith("install");
   });
 
+  it("init --pm pnpm passes packageManager", async () => {
+    process.argv = ["node", "grunt", "init", "--pm", "pnpm"];
+    await start();
+    expect(init).toHaveBeenCalledWith(process.cwd(), {
+      skipGlobals: false,
+      packageManager: "pnpm",
+    });
+  });
+
+  it("generate --pm pnpm runs pnpm", async () => {
+    process.argv = ["node", "grunt", "generate", "--pm", "pnpm"];
+    await start();
+    expect(execFileSync).toHaveBeenCalledWith("pnpm", ["run", "grunt:rulesync:generate"], {
+      cwd: process.cwd(),
+      stdio: "inherit",
+    });
+  });
+
+  it("setup --pm=yarn extra args omit npm --", async () => {
+    process.argv = ["node", "grunt", "setup", "--pm=yarn", "speak"];
+    await start();
+    expect(execFileSync).toHaveBeenCalledWith("yarn", ["run", "grunt:setup", "speak"], {
+      cwd: process.cwd(),
+      stdio: "inherit",
+    });
+  });
+
+  it("invalid --pm writes usage exit 1", async () => {
+    process.argv = ["node", "grunt", "generate", "--pm", "deno"];
+    await start();
+    expect(chunks.join("")).toBe(USAGE);
+    expect(process.exitCode).toBe(1);
+    expect(execFileSync).not.toHaveBeenCalled();
+  });
+
+  it("TTY menu then unknown manager asks", async () => {
+    detectPackageManager.mockReturnValue({ manager: null, source: null });
+    isInteractive.mockReturnValue(true);
+    select.mockResolvedValueOnce("generate").mockResolvedValueOnce("pnpm");
+    process.argv = ["node", "grunt"];
+    await start();
+    expect(select).toHaveBeenCalledTimes(2);
+    expect(execFileSync).toHaveBeenCalledWith("pnpm", ["run", "grunt:rulesync:generate"], {
+      cwd: process.cwd(),
+      stdio: "inherit",
+    });
+  });
+
+  it("TTY unknown manager asks then runs the choice", async () => {
+    detectPackageManager.mockReturnValue({ manager: null, source: null });
+    isInteractive.mockReturnValue(true);
+    select.mockResolvedValue("bun");
+    process.argv = ["node", "grunt", "generate"];
+    await start();
+    expect(select).toHaveBeenCalledWith({
+      message: PACKAGE_MANAGER_ASK,
+      options: [
+        { value: "npm", label: "npm" },
+        { value: "yarn", label: "yarn" },
+        { value: "pnpm", label: "pnpm" },
+        { value: "bun", label: "bun" },
+      ],
+    });
+    expect(execFileSync).toHaveBeenCalledWith("bun", ["run", "grunt:rulesync:generate"], {
+      cwd: process.cwd(),
+      stdio: "inherit",
+    });
+  });
+
+  it("non-interactive unknown manager writes hint and skips run", async () => {
+    detectPackageManager.mockReturnValue({ manager: null, source: null });
+    process.argv = ["node", "grunt", "generate"];
+    await start();
+    expect(chunks.join("")).toBe(`${UNKNOWN_PACKAGE_MANAGER}\n`);
+    expect(process.exitCode).toBe(1);
+    expect(execFileSync).not.toHaveBeenCalled();
+  });
+
   it("TTY init --skip-globals default confirm false maps to skip", async () => {
     isInteractive.mockReturnValue(true);
     confirm.mockResolvedValue(false);
@@ -432,6 +566,7 @@ describe("start", () => {
       expect.objectContaining({
         skipGlobals: true,
         applyGlobals: false,
+        packageManager: "npm",
         onPhase: expect.any(Function),
       }),
     );
@@ -462,3 +597,24 @@ describe("parseArgv --host", () => {
     });
   });
 });
+
+describe("parseArgv --pm", () => {
+  it("pair and equals", () => {
+    expect(parseArgv(["generate", "--pm", "PNPM"])).toMatchObject({
+      cmd: "generate",
+      pm: "pnpm",
+      pmError: false,
+    });
+    expect(parseArgv(["generate", "--pm=Yarn"])).toMatchObject({
+      pm: "yarn",
+      pmError: false,
+    });
+  });
+
+  it("missing, empty, flag, and unknown are pmError", () => {
+    expect(parseArgv(["generate", "--pm"])).toMatchObject({ pmError: true });
+    expect(parseArgv(["generate", "--pm="])).toMatchObject({ pmError: true });
+    expect(parseArgv(["generate", "--pm", "--yes"])).toMatchObject({ pmError: true });
+    expect(parseArgv(["generate", "--pm", "deno"])).toMatchObject({ pmError: true });
+  });
+});