@lovrozagar/grunt 0.5.2 → 0.6.1

package/cli/init.test.ts

@@ -1,3 +1,4 @@
+import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -5,6 +6,7 @@ import { fileURLToPath } from "node:url";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import {
   MAX_GUARDED_MARKDOWN_BYTES,
+  PRODUCT_SCRIPTS,
   composeGuardedMarkdown,
   destAlreadyInited,
   extractGruntBody,
@@ -15,6 +17,12 @@ import {
   guardedMarkdownDrift,
   healGuardedRootFile,
   init,
+  pruneRetired,
+  RETIRED_SKILLS,
+  RETIRED_AGENTS,
+  RETIRED_SCRIPTS,
+  RETIRED_PATHS,
+  RESERVED_SKILLS,
   LAUNCH_SCRIPTS,
   mergeClaudeSettings,
   mergeGitignore,
@@ -30,7 +38,6 @@ import {
   writeMergedGuardedFile,
 } from "./init.mjs";
 import { runGuardedRoots } from "../scripts/guarded-roots.mjs";
-import { stripJsonc } from "../scripts/grunt-config.mjs";
 
 const tmpDirs: string[] = [];
 afterEach(() => {
@@ -46,37 +53,9 @@ function tmp(prefix: string) {
 }
 
 const COPY_DIRS = [".rulesync", ".grok", ".codex", ".claude", ".agents"];
-const GRUNT_CONFIG_REL = path.join(".rulesync", "grunt.config.jsonc");
-const GRUNT_CONFIG_DEFAULTS = {
-  version: 1,
-  leftoverGate: "ask",
-  spawnMode: "cascade",
-};
 const GUARDED_MD_FILES = ["AGENTS.md", "CLAUDE.md"];
-const PRODUCT_FILES = [
-  "check-globals.mjs",
-  "emit-agent-shell-tools.mjs",
-  "emit-gemini.mjs",
-  "emit-maps.mjs",
-  "guarded-roots.mjs",
-  "emit-mcp-policy.mjs",
-  "gate-fat-tools.mjs",
-  "hooks-union.mjs",
-  "pipeline.mjs",
-  "grunt-job.mjs",
-  "grunt-config.mjs",
-  "parse-need.mjs",
-  "persist-handoff.mjs",
-  "persist-tmp.mjs",
-  "persist-plan.mjs",
-  "purge-global-mcps.mjs",
-  "scrub-spawn-prompt.mjs",
-  "scrub-text-lib.mjs",
-  "sync-global-settings.mjs",
-  "browser.mjs",
-  "doctor.mjs",
-  "skill-conflicts.mjs",
-];
+const PRODUCT_FILES = PRODUCT_SCRIPTS.filter((name) => name !== "scrub-text");
+const PKG_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), "..");
 
 const SRC_CLAUDE_SETTINGS = {
   permissions: {
@@ -118,12 +97,6 @@ const SRC_CLAUDE_SETTINGS = {
   enabledMcpjsonServers: [],
 };
 
-function readGruntConfig(root: string) {
-  const p = path.join(root, GRUNT_CONFIG_REL);
-  expect(fs.existsSync(p)).toBe(true);
-  return JSON.parse(stripJsonc(fs.readFileSync(p, "utf8")));
-}
-
 function stubPkgRoot(pkg: Record<string, unknown> = {
   name: "fixture-pkg",
   scripts: {
@@ -143,10 +116,6 @@ function stubPkgRoot(pkg: Record<string, unknown> = {
     fs.mkdirSync(path.join(root, d));
     fs.writeFileSync(path.join(root, d, "marker"), d);
   }
-  fs.writeFileSync(
-    path.join(root, GRUNT_CONFIG_REL),
-    `${JSON.stringify(GRUNT_CONFIG_DEFAULTS, null, 2)}\n`,
-  );
   fs.writeFileSync(
     path.join(root, ".claude", "settings.json"),
     `${JSON.stringify(SRC_CLAUDE_SETTINGS, null, 2)}\n`,
@@ -179,18 +148,22 @@ describe("samePath", () => {
   });
 });
 
+const GI_TMP = ".tmp/\n";
+
 describe("mergeGitignore", () => {
   it("creates .tmp/ when missing", () => {
     const dest = tmp("gi-miss-");
     mergeGitignore(dest);
-    expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(".tmp/\n");
+    expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(GI_TMP);
   });
 
-  it("noop when .tmp/ present", () => {
+  it("noop when .tmp/ already present", () => {
     const dest = tmp("gi-slash-");
     fs.writeFileSync(path.join(dest, ".gitignore"), "foo\n.tmp/\nbar\n");
     mergeGitignore(dest);
-    expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe("foo\n.tmp/\nbar\n");
+    expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(
+      "foo\n.tmp/\nbar\n",
+    );
   });
 
   it("noop when .tmp present", () => {
@@ -200,12 +173,21 @@ describe("mergeGitignore", () => {
     expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(".tmp\n");
   });
 
+  it("noop when .tmp/ present in mixed file", () => {
+    const dest = tmp("gi-both-");
+    fs.writeFileSync(path.join(dest, ".gitignore"), `foo\n${GI_TMP}bar\n`);
+    mergeGitignore(dest);
+    expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(
+      `foo\n${GI_TMP}bar\n`,
+    );
+  });
+
   it("appends after trailing newline", () => {
     const dest = tmp("gi-nl-");
     fs.writeFileSync(path.join(dest, ".gitignore"), "node_modules/\n");
     mergeGitignore(dest);
     expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(
-      "node_modules/\n.tmp/\n",
+      `node_modules/\n${GI_TMP}`,
     );
   });
 
@@ -214,7 +196,7 @@ describe("mergeGitignore", () => {
     fs.writeFileSync(path.join(dest, ".gitignore"), "node_modules/");
     mergeGitignore(dest);
     expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(
-      "node_modules/\n.tmp/\n",
+      `node_modules/\n${GI_TMP}`,
     );
   });
 
@@ -222,7 +204,7 @@ describe("mergeGitignore", () => {
     const dest = tmp("gi-empty-");
     fs.writeFileSync(path.join(dest, ".gitignore"), "");
     mergeGitignore(dest);
-    expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(".tmp/\n");
+    expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(GI_TMP);
   });
 });
 
@@ -1550,9 +1532,9 @@ describe("init", () => {
       if (d === ".claude") continue;
       expect(fs.readFileSync(path.join(dest, d, "marker"), "utf8")).toBe(d);
     }
-    expect(readGruntConfig(dest)).toEqual(GRUNT_CONFIG_DEFAULTS);
-    expect(PRODUCT_FILES).toContain("grunt-config.mjs");
-    expect(fs.statSync(path.join(dest, "scripts", "grunt-config.mjs")).isFile()).toBe(true);
+    expect(fs.existsSync(path.join(dest, ".rulesync", "grunt.config.jsonc"))).toBe(false);
+    expect(PRODUCT_FILES).not.toContain("grunt-config.mjs");
+    expect(fs.existsSync(path.join(dest, "scripts", "grunt-config.mjs"))).toBe(false);
     expect(fs.readFileSync(path.join(dest, ".claude", "marker"), "utf8")).toBe(".claude");
     const settings = JSON.parse(
       fs.readFileSync(path.join(dest, ".claude", "settings.json"), "utf8"),
@@ -1626,6 +1608,109 @@ describe("init", () => {
     expect(fs.readFileSync(path.join(pkgRoot, ".gitignore"), "utf8")).toBe(".tmp/\n");
   });
 
+  it("prunes retired 0.5 skills and agents on dest", () => {
+    const pkgRoot = stubPkgRoot();
+    const dest = tmp("grunt-prune-");
+    fs.mkdirSync(path.join(dest, ".rulesync", "skills", "solo"), { recursive: true });
+    fs.writeFileSync(path.join(dest, ".rulesync", "skills", "solo", "SKILL.md"), "old");
+    fs.mkdirSync(path.join(dest, ".rulesync", "skills", "parent"), { recursive: true });
+    fs.mkdirSync(path.join(dest, ".rulesync", "skills", "cascade"), { recursive: true });
+    fs.mkdirSync(path.join(dest, ".claude", "agents"), { recursive: true });
+    fs.writeFileSync(path.join(dest, ".claude", "agents", "implementer.md"), "old");
+    fs.writeFileSync(path.join(dest, ".claude", "agents", "thinker.md"), "old");
+    expect(RETIRED_SKILLS).toEqual(["parent", "solo", "cascade"]);
+    expect(RETIRED_AGENTS).toEqual(["implementer", "thinker"]);
+    expect(RETIRED_SCRIPTS).toEqual(["telemetry.mjs", "grunt-config.mjs"]);
+    expect(RETIRED_PATHS).toEqual([
+      ".grok/parent.md",
+      ".grok/skills/shared",
+      ".rulesync/grunt.config.jsonc",
+      ".rulesync/grunt.config.local.jsonc",
+      ".rulesync/grunt.config.local.jsonc.example",
+    ]);
+    expect(RESERVED_SKILLS).toEqual([
+      "ask",
+      "auto",
+      "browser",
+      "clasp",
+      "commit",
+      "commit-and-push",
+      "commit-push",
+      "commit-push-deploy",
+      "commit-push-release",
+      "explain",
+      "google-workspace",
+      "handoff",
+      "implement-plan",
+      "listen",
+      "pickup",
+      "speak",
+      "tmp",
+      "write-plan",
+    ]);
+    expect(RESERVED_SKILLS).not.toEqual(expect.arrayContaining(RETIRED_SKILLS));
+    init(dest, { pkgRoot, execFileSync: vi.fn() });
+    expect(fs.existsSync(path.join(dest, ".rulesync", "skills", "solo"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".rulesync", "skills", "parent"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".rulesync", "skills", "cascade"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".claude", "agents", "implementer.md"))).toBe(
+      false,
+    );
+    expect(fs.existsSync(path.join(dest, ".claude", "agents", "thinker.md"))).toBe(false);
+    pruneRetired(dest, { pkgRoot });
+  });
+
+  it("prunes retired scripts/paths, reserved-not-packaged skills, and grok roles; keeps consumer extras", () => {
+    const pkgRoot = stubPkgRoot();
+    fs.mkdirSync(path.join(pkgRoot, ".rulesync", "skills", "tmp"), { recursive: true });
+    fs.writeFileSync(path.join(pkgRoot, ".rulesync", "skills", "tmp", "SKILL.md"), "pkg tmp");
+    const dest = tmp("grunt-prune-extra-");
+    fs.mkdirSync(path.join(dest, ".rulesync", "skills", "tmp"), { recursive: true });
+    fs.writeFileSync(path.join(dest, ".rulesync", "skills", "tmp", "SKILL.md"), "old tmp");
+    fs.mkdirSync(path.join(dest, ".rulesync", "skills", "browser"), { recursive: true });
+    fs.writeFileSync(path.join(dest, ".rulesync", "skills", "browser", "SKILL.md"), "stale reserved");
+    fs.mkdirSync(path.join(dest, ".rulesync", "skills", "acme"), { recursive: true });
+    fs.writeFileSync(path.join(dest, ".rulesync", "skills", "acme", "SKILL.md"), "consumer");
+    fs.mkdirSync(path.join(dest, ".grok", "roles"), { recursive: true });
+    fs.writeFileSync(path.join(dest, ".grok", "roles", "implementer.toml"), "old");
+    fs.writeFileSync(path.join(dest, ".grok", "roles", "thinker.toml"), "old");
+    fs.writeFileSync(path.join(dest, ".grok", "parent.md"), "pointer");
+    fs.mkdirSync(path.join(dest, ".grok", "skills", "shared"), { recursive: true });
+    fs.mkdirSync(path.join(dest, "scripts"), { recursive: true });
+    fs.writeFileSync(path.join(dest, "scripts", "telemetry.mjs"), "old telemetry");
+    fs.writeFileSync(path.join(dest, "scripts", "grunt-config.mjs"), "old config");
+    fs.writeFileSync(path.join(dest, "scripts", "mine.mjs"), "keep");
+    fs.writeFileSync(path.join(dest, ".rulesync", "grunt.config.jsonc"), '{"version":1}\n');
+    fs.writeFileSync(path.join(dest, ".rulesync", "grunt.config.local.jsonc"), '{"sessionGate":"ask"}\n');
+    fs.writeFileSync(
+      path.join(dest, ".rulesync", "grunt.config.local.jsonc.example"),
+      '{"sessionGate":"ask"}\n',
+    );
+    fs.mkdirSync(path.join(dest, ".gemini", "agents", "implementer"), { recursive: true });
+    fs.writeFileSync(path.join(dest, ".gemini", "agents", "implementer", "agent.md"), "old");
+    init(dest, { pkgRoot, execFileSync: vi.fn() });
+    expect(fs.readFileSync(path.join(dest, ".rulesync", "skills", "tmp", "SKILL.md"), "utf8")).toBe(
+      "pkg tmp",
+    );
+    expect(fs.existsSync(path.join(dest, ".rulesync", "skills", "browser"))).toBe(false);
+    expect(fs.readFileSync(path.join(dest, ".rulesync", "skills", "acme", "SKILL.md"), "utf8")).toBe(
+      "consumer",
+    );
+    expect(fs.existsSync(path.join(dest, ".grok", "roles", "implementer.toml"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".grok", "roles", "thinker.toml"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".grok", "parent.md"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".grok", "skills", "shared"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, "scripts", "telemetry.mjs"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, "scripts", "grunt-config.mjs"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".rulesync", "grunt.config.jsonc"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".rulesync", "grunt.config.local.jsonc"))).toBe(false);
+    expect(
+      fs.existsSync(path.join(dest, ".rulesync", "grunt.config.local.jsonc.example")),
+    ).toBe(false);
+    expect(fs.readFileSync(path.join(dest, "scripts", "mine.mjs"), "utf8")).toBe("keep");
+    expect(fs.existsSync(path.join(dest, ".gemini", "agents", "implementer"))).toBe(false);
+  });
+
   it("omitted pkgRoot uses built-in PKG_ROOT; exec mocked", () => {
     const dest = tmp("grunt-realroot-");
     const exec = vi.fn();
@@ -1638,9 +1723,12 @@ describe("init", () => {
     expect(claude.split("<!-- grunt:begin -->")).toHaveLength(2);
     expect(claude.split("<!-- grunt:end -->")).toHaveLength(2);
     expect(fs.existsSync(path.join(dest, "scripts", "scrub-text"))).toBe(true);
-    expect(fs.existsSync(path.join(dest, "scripts", "grunt-config.mjs"))).toBe(true);
+    expect(fs.existsSync(path.join(dest, "scripts", "grunt-config.mjs"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, "scripts", "speak.mjs"))).toBe(true);
+    expect(fs.existsSync(path.join(dest, "scripts", "listen.mjs"))).toBe(true);
+    expect(fs.existsSync(path.join(dest, "scripts", "google-workspace.mjs"))).toBe(true);
     expect(fs.existsSync(path.join(dest, ".claude", "settings.json"))).toBe(true);
-    expect(readGruntConfig(dest)).toEqual(GRUNT_CONFIG_DEFAULTS);
+    expect(fs.existsSync(path.join(dest, ".rulesync", "grunt.config.jsonc"))).toBe(false);
     expect(exec.mock.calls.map((c) => c[1])).toEqual([
       ["install"],
       ["run", "grunt:rulesync:generate"],
@@ -1829,25 +1917,25 @@ describe("init", () => {
 
   it("warns when dest skill differs from packaged then force-overwrites; keeps extras", () => {
     const pkgRoot = stubPkgRoot();
-    const pkgSkill = path.join(pkgRoot, ".rulesync", "skills", "parent");
+    const pkgSkill = path.join(pkgRoot, ".rulesync", "skills", "explain");
     fs.mkdirSync(pkgSkill, { recursive: true });
-    fs.writeFileSync(path.join(pkgSkill, "SKILL.md"), "grunt-parent\n");
+    fs.writeFileSync(path.join(pkgSkill, "SKILL.md"), "grunt-explain\n");
     const dest = tmp("grunt-sk-conflict-");
-    const destSkill = path.join(dest, ".rulesync", "skills", "parent");
+    const destSkill = path.join(dest, ".rulesync", "skills", "explain");
     const destExtra = path.join(dest, ".rulesync", "skills", "my-extra");
     fs.mkdirSync(destSkill, { recursive: true });
     fs.mkdirSync(destExtra, { recursive: true });
-    fs.writeFileSync(path.join(destSkill, "SKILL.md"), "custom-parent\n");
+    fs.writeFileSync(path.join(destSkill, "SKILL.md"), "custom-explain\n");
     fs.writeFileSync(path.join(destExtra, "SKILL.md"), "keep-me\n");
     const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
     init(dest, { pkgRoot, execFileSync: vi.fn(), skipGlobals: true });
     expect(
       warnSpy.mock.calls.some(
-        (c) => String(c[0]).includes("parent") && String(c[0]).includes("re-init overwrites"),
+        (c) => String(c[0]).includes("explain") && String(c[0]).includes("re-init overwrites"),
       ),
     ).toBe(true);
     warnSpy.mockRestore();
-    expect(fs.readFileSync(path.join(destSkill, "SKILL.md"), "utf8")).toBe("grunt-parent\n");
+    expect(fs.readFileSync(path.join(destSkill, "SKILL.md"), "utf8")).toBe("grunt-explain\n");
     expect(fs.readFileSync(path.join(destExtra, "SKILL.md"), "utf8")).toBe("keep-me\n");
   });
 });
@@ -1884,3 +1972,98 @@ describe("destAlreadyInited / shouldAutoSkipGlobals", () => {
   });
 });
 
+function spawnDest(dest: string, args: string[], env: NodeJS.ProcessEnv = process.env) {
+  return spawnSync(process.execPath, args, {
+    cwd: dest,
+    encoding: "utf8",
+    env,
+  });
+}
+
+const PARENT_IMPORT_RE =
+  /(?:from\s+|import\s*\(\s*)["'`](\.\.[^"'`]*)["'`]/g;
+const RELATIVE_IMPORT_RE =
+  /(?:from\s+|import\s*\(\s*)["'`](\.[^"'`]+)["'`]/g;
+
+function relativeSpecs(text: string, re: RegExp) {
+  const out: string[] = [];
+  const copy = new RegExp(re.source, "g");
+  let m: RegExpExecArray | null;
+  while ((m = copy.exec(text))) out.push(m[1]);
+  return out;
+}
+
+describe("product scripts are consumer-safe", () => {
+  it("package.json files lists every PRODUCT_SCRIPTS entry", () => {
+    const pkg = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf8"));
+    for (const name of PRODUCT_SCRIPTS) {
+      expect(pkg.files).toContain(`scripts/${name}`);
+    }
+  });
+
+  it("do not parent-import (from or import()) — init copies scripts/ only", () => {
+    for (const name of PRODUCT_FILES) {
+      const text = fs.readFileSync(path.join(PKG_ROOT, "scripts", name), "utf8");
+      expect(relativeSpecs(text, PARENT_IMPORT_RE), name).toEqual([]);
+    }
+  });
+
+  it("repro: dest node ./scripts/guarded-roots.mjs generate misses ../cli/init.mjs", () => {
+    const dest = tmp("repro-cli-miss-");
+    fs.mkdirSync(path.join(dest, "scripts"));
+    fs.writeFileSync(
+      path.join(dest, "scripts", "broken.mjs"),
+      'import { snapshotGuardedRoots } from "../cli/init.mjs";\n',
+    );
+    const r = spawnDest(dest, ["./scripts/broken.mjs", "generate"]);
+    expect(r.status).not.toBe(0);
+    expect(r.stderr).toMatch(/ERR_MODULE_NOT_FOUND/);
+    expect(r.stderr).toMatch(/cli\/init\.mjs/);
+  });
+
+  it("after init, copied scripts' relative imports exist and generate loads", () => {
+    const dest = tmp("init-generate-");
+    init(dest, {
+      pkgRoot: PKG_ROOT,
+      execFileSync: vi.fn(),
+      skipGlobals: true,
+      applyGlobals: false,
+    });
+    expect(fs.existsSync(path.join(dest, "cli"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, "scripts", "guarded-roots.mjs"))).toBe(true);
+
+    for (const name of PRODUCT_FILES) {
+      const file = path.join(dest, "scripts", name);
+      expect(fs.existsSync(file), name).toBe(true);
+      const text = fs.readFileSync(file, "utf8");
+      for (const spec of relativeSpecs(text, RELATIVE_IMPORT_RE)) {
+        const resolved = path.resolve(path.dirname(file), spec);
+        expect(fs.existsSync(resolved), `${name} -> ${spec}`).toBe(true);
+      }
+    }
+
+    const loaded = spawnDest(dest, ["./scripts/guarded-roots.mjs"]);
+    expect(loaded.status).toBe(1);
+    expect(loaded.stderr).toBe("usage: guarded-roots.mjs generate|check|watch\n");
+    expect(loaded.stderr).not.toMatch(/ERR_MODULE_NOT_FOUND/);
+
+    const gen = spawnDest(dest, ["./scripts/guarded-roots.mjs", "generate"], {
+      ...process.env,
+      PATH: ["/usr/bin", "/bin"].join(path.delimiter),
+    });
+    expect(gen.stderr).not.toMatch(/ERR_MODULE_NOT_FOUND/);
+    expect(gen.stderr).not.toMatch(/cli\/init\.mjs/);
+    expect(`${gen.stderr}${gen.stdout}`).toMatch(/rulesync|spawn|not found|ENOENT/i);
+
+    for (const name of ["guarded-roots.mjs", "emit-gemini.mjs", "setup.mjs"]) {
+      const r = spawnDest(dest, [
+        "--input-type=module",
+        "-e",
+        `import(${JSON.stringify(`./scripts/${name}`)})`,
+      ]);
+      expect(r.status, `${name} load\n${r.stderr}`).toBe(0);
+      expect(r.stderr, name).not.toMatch(/ERR_MODULE_NOT_FOUND/);
+    }
+  });
+});
+

package/cli/prompt.mjs

@@ -1,36 +1,9 @@
-import * as clack from "@clack/prompts"
-
-export function isInteractive({
-  argv = process.argv.slice(2),
-  env = process.env,
-  stdin = process.stdin,
-  stdout = process.stdout,
-} = {}) {
-  if (!stdin?.isTTY || !stdout?.isTTY) return false
-  const ci = env.CI
-  if (ci != null && ci !== "" && ci !== "0" && ci !== "false") return false
-  for (const a of argv) {
-    if (a === "--yes" || a === "-y" || a === "--non-interactive") return false
-  }
-  return true
-}
-
-export function bailIfCancel(value) {
-  if (clack.isCancel(value)) {
-    clack.cancel("Aborted")
-    process.exit(0)
-  }
-  return value
-}
-
-export async function select(opts) {
-  return bailIfCancel(await clack.select(opts))
-}
-
-export async function confirm(opts) {
-  return bailIfCancel(await clack.confirm(opts))
-}
-
-export function spinner() {
-  return clack.spinner()
-}
+export {
+  bailIfCancel,
+  confirm,
+  isInteractive,
+  password,
+  select,
+  spinner,
+  text,
+} from "../scripts/prompt.mjs"

package/cli/prompt.test.ts

@@ -2,6 +2,8 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 
 const clackSelect = vi.hoisted(() => vi.fn());
 const clackConfirm = vi.hoisted(() => vi.fn());
+const clackText = vi.hoisted(() => vi.fn());
+const clackPassword = vi.hoisted(() => vi.fn());
 const clackSpinner = vi.hoisted(() => vi.fn());
 const clackIsCancel = vi.hoisted(() => vi.fn());
 const clackCancel = vi.hoisted(() => vi.fn());
@@ -9,6 +11,8 @@ const clackCancel = vi.hoisted(() => vi.fn());
 vi.mock("@clack/prompts", () => ({
   select: clackSelect,
   confirm: clackConfirm,
+  text: clackText,
+  password: clackPassword,
   spinner: clackSpinner,
   isCancel: clackIsCancel,
   cancel: clackCancel,
@@ -18,8 +22,10 @@ import {
   bailIfCancel,
   confirm,
   isInteractive,
+  password,
   select,
   spinner,
+  text,
 } from "./prompt.mjs";
 
 function tty(isTTY: boolean) {
@@ -196,4 +202,12 @@ describe("clack wrappers", () => {
     expect(spinner()).toBe(s);
     expect(clackSpinner).toHaveBeenCalledOnce();
   });
+
+  it("text and password bail then return", async () => {
+    clackText.mockResolvedValue("proj");
+    clackPassword.mockResolvedValue("sk_x");
+    clackIsCancel.mockReturnValue(false);
+    await expect(text({ message: "Project ID" })).resolves.toBe("proj");
+    await expect(password({ message: "API key" })).resolves.toBe("sk_x");
+  });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lovrozagar/grunt",
-  "version": "0.5.2",
+  "version": "0.6.1",
   "description": "Multi-agent orchestrator SoT — deep-merge rulesync trees, product scripts, and generate pipeline into a consumer repo",
   "keywords": [
     "agents",
@@ -28,15 +28,16 @@
     "scripts/emit-agent-shell-tools.mjs",
     "scripts/emit-gemini.mjs",
     "scripts/emit-maps.mjs",
+    "scripts/guarded-md.mjs",
     "scripts/guarded-roots.mjs",
     "scripts/emit-mcp-policy.mjs",
     "scripts/gate-fat-tools.mjs",
     "scripts/hooks-union.mjs",
     "scripts/pipeline.mjs",
     "scripts/grunt-job.mjs",
-    "scripts/grunt-config.mjs",
     "scripts/parse-need.mjs",
     "scripts/persist-handoff.mjs",
+    "scripts/persist-implementation.mjs",
     "scripts/persist-tmp.mjs",
     "scripts/persist-plan.mjs",
     "scripts/purge-global-mcps.mjs",
@@ -44,6 +45,12 @@
     "scripts/scrub-text-lib.mjs",
     "scripts/sync-global-settings.mjs",
     "scripts/browser.mjs",
+    "scripts/speak.mjs",
+    "scripts/listen.mjs",
+    "scripts/google-workspace.mjs",
+    "scripts/interactive.mjs",
+    "scripts/prompt.mjs",
+    "scripts/setup.mjs",
     "scripts/doctor.mjs",
     "scripts/skill-conflicts.mjs",
     "scripts/scrub-text",
@@ -73,6 +80,7 @@
     "hooks:union": "node scripts/hooks-union.mjs",
     "hooks:check": "node scripts/hooks-union.mjs --check",
     "doctor": "node ./scripts/doctor.mjs",
+    "setup": "node ./scripts/setup.mjs",
     "rulesync:doctor": "rulesync doctor",
     "sync:globals": "node scripts/sync-global-settings.mjs",
     "sync:globals:check": "node scripts/check-globals.mjs",