@defold-typescript/cli 0.5.4 → 0.6.0

package/src/dispatch.ts

@@ -2,10 +2,17 @@ import { existsSync, readFileSync } from "node:fs";
 import * as path from "node:path";
 import type { RegistryTarget } from "./api-registry";
 import { CURRENT_STABLE_SURFACE_ID, selectApiSurface } from "./api-surface";
+import {
+  type DefoldIo,
+  defaultDefoldIo,
+  isDefoldSubcommand,
+  runDefoldCommand,
+} from "./bob-command";
 import { runBuild } from "./build";
 import { readCliVersion } from "./cli-version";
 import { readDefoldVersionPin, resolveDefoldVersion } from "./defold-version";
 import { runInit } from "./init";
+import { installHint } from "./install-reminder";
 import { renderResult } from "./json-output";
 import {
   ensureMaterializedReference,
@@ -14,7 +21,9 @@ import {
   type RefDocResolveOptions,
   resolveCurrentSurfaceGeneratedDir,
 } from "./materialize";
-import { detectScriptKinds, selectScriptKind } from "./script-kind";
+import { runSetupDebug } from "./setup-debug";
+import { applyWallSelection, currentWalledDirs, eligibleWalls } from "./wall";
+import { type CheckboxPrompt, runWallInteractive } from "./wall-interactive";
 import {
   type RunWatchHandle,
   type RunWatchOptions,
@@ -37,9 +46,16 @@ export interface DispatchInternals {
   readonly resolveOpts?: RefDocResolveOptions;
   readonly refDocRegistry?: readonly RegistryTarget[];
   readonly cliVersion?: string;
+  readonly defoldIo?: Partial<DefoldIo>;
+  // `wall` takes its target directories as positionals (not a cwd path arg like
+  // the other commands), so tests inject the project root and TTY state here.
+  readonly cwd?: string;
+  readonly isTty?: boolean;
+  readonly wallCheckbox?: CheckboxPrompt;
 }
 
-const USAGE = "Usage: defold-typescript <init|build|watch> [path]\n";
+const USAGE = "Usage: defold-typescript <init|build|watch|wall|setup-debug|defold> [path]\n";
+const DEFOLD_USAGE = "Usage: defold-typescript defold <resolve|build|bundle> [path]\n";
 
 function parseDefoldVersionFlag(argv: string[]): { flag: string | undefined; rest: string[] } {
   let flag: string | undefined;
@@ -58,6 +74,45 @@ function parseDefoldVersionFlag(argv: string[]): { flag: string | undefined; res
   return { flag, rest };
 }
 
+function parseScriptFlag(argv: string[]): { script: string | undefined; rest: string[] } {
+  let script: string | undefined;
+  const rest: string[] = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--script") {
+      script = argv[i + 1];
+      i++;
+    } else if (arg?.startsWith("--script=")) {
+      script = arg.slice("--script=".length);
+    } else if (arg !== undefined) {
+      rest.push(arg);
+    }
+  }
+  return { script, rest };
+}
+
+function parseValueFlag(
+  argv: string[],
+  name: string,
+): { value: string | undefined; rest: string[] } {
+  const long = `--${name}`;
+  const eq = `${long}=`;
+  let value: string | undefined;
+  const rest: string[] = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === long) {
+      value = argv[i + 1];
+      i++;
+    } else if (arg?.startsWith(eq)) {
+      value = arg.slice(eq.length);
+    } else if (arg !== undefined) {
+      rest.push(arg);
+    }
+  }
+  return { value, rest };
+}
+
 function readProjectPin(cwd: string): string | undefined {
   const pkgPath = path.join(cwd, "package.json");
   if (!existsSync(pkgPath)) {
@@ -88,8 +143,24 @@ export function dispatch(
   }
 
   const force = argv.includes("--force");
-  const { flag: defoldVersionFlag, rest: nonFlagArgs } = parseDefoldVersionFlag(argv);
-  const positional = nonFlagArgs.filter((a) => a !== "--json" && a !== "--force");
+  const suppressInstallReminder = argv.includes("--suppress-install-reminder");
+  const wallRemove = argv.includes("--remove");
+  const wallList = argv.includes("--list");
+  const { flag: defoldVersionFlag, rest: afterVersionArgs } = parseDefoldVersionFlag(argv);
+  const { script: scriptFlag, rest: afterScriptArgs } = parseScriptFlag(afterVersionArgs);
+  const { value: javaFlag, rest: afterJavaArgs } = parseValueFlag(afterScriptArgs, "java");
+  const { value: buildServerFlag, rest: nonFlagArgs } = parseValueFlag(
+    afterJavaArgs,
+    "build-server",
+  );
+  const positional = nonFlagArgs.filter(
+    (a) =>
+      a !== "--json" &&
+      a !== "--force" &&
+      a !== "--suppress-install-reminder" &&
+      a !== "--remove" &&
+      a !== "--list",
+  );
   const [command, ...rest] = positional;
   const cwd = rest[0] ? path.resolve(rest[0]) : process.cwd();
 
@@ -103,7 +174,7 @@ export function dispatch(
 
   if (command === "init") {
     try {
-      const { written, scriptKind } = runInit({ cwd, force });
+      const { written } = runInit({ cwd, force });
       if (json) {
         io.stdout.write(
           renderResult({
@@ -111,13 +182,16 @@ export function dispatch(
             written,
             defoldVersion: resolvedVersion,
             apiSurface,
-            scriptKind,
+            installCommand: installHint(),
           }),
         );
       } else {
         io.stdout.write(
           `defold-typescript init: wrote ${written.length} files: ${written.join(", ")}\n`,
         );
+        if (!suppressInstallReminder) {
+          io.stdout.write(`Next: run \`${installHint()}\` to install dependencies.\n`);
+        }
       }
       return 0;
     } catch (err) {
@@ -131,10 +205,57 @@ export function dispatch(
     }
   }
 
+  if (command === "setup-debug") {
+    return (async (): Promise<number> => {
+      const result = await runSetupDebug({
+        cwd,
+        json,
+        ...(scriptFlag !== undefined ? { script: scriptFlag } : {}),
+      });
+      if (json) {
+        io.stdout.write(
+          renderResult(
+            result.ok
+              ? {
+                  command: "setup-debug",
+                  written: result.written,
+                  actions: result.actions,
+                  manualSteps: result.manualSteps,
+                  ...(result.addedTo !== undefined ? { addedTo: result.addedTo } : {}),
+                  removedFrom: result.removedFrom ?? [],
+                  bootPath: result.bootPath ?? [],
+                }
+              : { command: "setup-debug", error: result.error ?? "setup-debug failed" },
+          ),
+        );
+      } else if (result.ok) {
+        io.stdout.write(
+          `defold-typescript setup-debug: wrote ${result.written.length} files: ${result.written.join(", ")}\n`,
+        );
+        if (result.addedTo !== undefined) {
+          io.stdout.write(`Debugger bootstrap added to: ${result.addedTo}\n`);
+        }
+        if (result.removedFrom !== undefined && result.removedFrom.length > 0) {
+          io.stdout.write(`Removed stale bootstrap from: ${result.removedFrom.join(", ")}\n`);
+        }
+        if (result.bootPath !== undefined && result.bootPath.length > 0) {
+          io.stdout.write(`Boot path: ${result.bootPath.join(" -> ")}\n`);
+        }
+        io.stdout.write("Remaining manual steps:\n");
+        for (const step of result.manualSteps) {
+          io.stdout.write(`  - ${step}\n`);
+        }
+      } else {
+        io.stderr.write(`${result.error}\n`);
+      }
+      return result.ok ? 0 : 1;
+    })();
+  }
+
   if (command === "build") {
-    const scriptKind = selectScriptKind(detectScriptKinds(cwd));
     const reportBuild = (written: readonly string[], materializedDir: string | null): number => {
       ensureMaterializedReference(cwd, materializedDir);
+      // walls are opt-in via the wall command
       if (json) {
         io.stdout.write(
           renderResult({
@@ -142,7 +263,6 @@ export function dispatch(
             written,
             defoldVersion: resolvedVersion,
             apiSurface,
-            scriptKind,
             materializedSurface: materializedDir,
           }),
         );
@@ -176,7 +296,6 @@ export function dispatch(
           const { materializedDir } = await materializeRefDocSurface({
             cwd,
             surfaceId,
-            scriptKind,
             ...(internals?.resolveOpts ? { resolveOpts: internals.resolveOpts } : {}),
             ...(internals?.refDocRegistry ? { registry: internals.refDocRegistry } : {}),
           });
@@ -200,7 +319,6 @@ export function dispatch(
         cwd,
         surface,
         sourceGeneratedDir,
-        scriptKind,
       });
       return reportBuild(written, materializedDir);
     } catch (err) {
@@ -220,14 +338,13 @@ export function dispatch(
       const sourceGeneratedDir =
         internals?.sourceGeneratedDir ?? resolveCurrentSurfaceGeneratedDir();
       syncSurface = (): void => {
-        const scriptKind = selectScriptKind(detectScriptKinds(cwd));
         const { materializedDir } = materializeApiSurface({
           cwd,
           surface,
           sourceGeneratedDir,
-          scriptKind,
         });
         ensureMaterializedReference(cwd, materializedDir);
+        // walls are opt-in via the wall command
       };
       componentWatcherFactory = internals
         ? internals.componentWatcherFactory
@@ -243,6 +360,7 @@ export function dispatch(
         ...(internals?.debounceMs !== undefined ? { debounceMs: internals.debounceMs } : {}),
         ...(syncSurface ? { syncSurface } : {}),
         ...(componentWatcherFactory ? { componentWatcherFactory } : {}),
+        ...(json ? { json: true } : {}),
       };
       const handle = runWatch(watchOpts);
       if (internals) {
@@ -258,18 +376,15 @@ export function dispatch(
     };
 
     // A pinned ref-doc surface is generated on the fly, so it has no
-    // `syncSurface`; narrow it once at startup the same way `build` does, then
-    // start the watcher. A single detected kind drops the forbidden restricted
-    // namespaces; mixed/none keeps the full surface. Live re-narrowing of
-    // ref-doc surfaces stays deferred.
+    // `syncSurface`; generate it once at startup the same way `build` does, then
+    // start the watcher. The full surface materializes; walls are opt-in via the
+    // wall command.
     if (isRefDocSurface) {
       const surfaceId = surface.surfaceId as string;
-      const scriptKind = selectScriptKind(detectScriptKinds(cwd));
       return (async (): Promise<number> => {
         const { materializedDir } = await materializeRefDocSurface({
           cwd,
           surfaceId,
-          scriptKind,
           ...(internals?.resolveOpts ? { resolveOpts: internals.resolveOpts } : {}),
           ...(internals?.refDocRegistry ? { registry: internals.refDocRegistry } : {}),
         });
@@ -281,6 +396,137 @@ export function dispatch(
     return launchWatch();
   }
 
+  if (command === "wall") {
+    const wallCwd = internals?.cwd ?? process.cwd();
+    const dirs = rest;
+    const toJsonWall = (w: { dir: string; kind: string }): { dir: string; kind: string } => ({
+      dir: w.dir,
+      kind: w.kind,
+    });
+    const reportWalls = (walls: { dir: string; kind: string }[]): void => {
+      if (json) {
+        io.stdout.write(renderResult({ command: "wall", directoryWalls: walls.map(toJsonWall) }));
+      } else if (walls.length === 0) {
+        io.stdout.write("defold-typescript wall: no directories walled\n");
+      } else {
+        io.stdout.write(`defold-typescript wall: walled ${walls.map((w) => w.dir).join(", ")}\n`);
+      }
+    };
+
+    if (wallList) {
+      const current = currentWalledDirs(wallCwd);
+      const eligible = eligibleWalls(wallCwd);
+      const currentWalls = eligible.filter((w) => current.includes(w.dir));
+      if (json) {
+        io.stdout.write(
+          renderResult({
+            command: "wall",
+            directoryWalls: currentWalls.map(toJsonWall),
+            eligible: eligible.map(toJsonWall),
+          }),
+        );
+      } else {
+        io.stdout.write(
+          `defold-typescript wall: walled [${current.join(", ")}]; eligible [${eligible
+            .map((w) => w.dir)
+            .join(", ")}]\n`,
+        );
+      }
+      return 0;
+    }
+
+    if (dirs.length > 0) {
+      try {
+        const current = currentWalledDirs(wallCwd);
+        const desired = wallRemove
+          ? current.filter((d) => !dirs.includes(d))
+          : [...current, ...dirs];
+        reportWalls(applyWallSelection(wallCwd, desired));
+        return 0;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (json) {
+          io.stdout.write(renderResult({ command: "wall", error: message }));
+        } else {
+          io.stderr.write(`${message}\n`);
+        }
+        return 1;
+      }
+    }
+
+    // `--json` is machine-driven intent, so it never prompts even on a TTY.
+    const interactive = !json && (internals?.isTty ?? Boolean(process.stdout.isTTY));
+    if (!interactive) {
+      io.stderr.write(
+        "defold-typescript wall: no directory given; pass <dir> or run in a terminal for the interactive menu\n",
+      );
+      return 1;
+    }
+    return (async (): Promise<number> => {
+      try {
+        reportWalls(
+          await runWallInteractive(
+            wallCwd,
+            internals?.wallCheckbox ? { checkbox: internals.wallCheckbox } : {},
+          ),
+        );
+        return 0;
+      } catch (err) {
+        io.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+      }
+    })();
+  }
+
+  if (command === "defold") {
+    const subcommand = rest[0];
+    const defoldCwd = rest[1] ? path.resolve(rest[1]) : process.cwd();
+    if (!isDefoldSubcommand(subcommand)) {
+      io.stderr.write(DEFOLD_USAGE);
+      return 1;
+    }
+    const javaOverride = javaFlag ?? process.env.DEFOLD_JAVA;
+    const defoldIo: DefoldIo = { ...defaultDefoldIo(), ...internals?.defoldIo };
+    return (async (): Promise<number> => {
+      try {
+        const result = await runDefoldCommand({
+          cwd: defoldCwd,
+          subcommand,
+          ...(javaOverride !== undefined ? { java: javaOverride } : {}),
+          ...(buildServerFlag !== undefined ? { buildServer: buildServerFlag } : {}),
+          io: defoldIo,
+        });
+        if (json) {
+          io.stdout.write(
+            renderResult(
+              result.ok
+                ? { command: "defold", subcommand: result.subcommand, exitCode: result.exitCode }
+                : {
+                    command: "defold",
+                    subcommand: result.subcommand,
+                    exitCode: result.exitCode,
+                    error: `bob ${result.subcommand} exited with code ${result.exitCode}`,
+                  },
+            ),
+          );
+        } else if (!result.ok) {
+          io.stderr.write(
+            `defold-typescript defold ${result.subcommand}: bob exited with code ${result.exitCode}\n`,
+          );
+        }
+        return result.exitCode;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (json) {
+          io.stdout.write(renderResult({ command: "defold", subcommand, error: message }));
+        } else {
+          io.stderr.write(`${message}\n`);
+        }
+        return 1;
+      }
+    })();
+  }
+
   io.stderr.write(USAGE);
   return 1;
 }

package/src/init.ts

@@ -5,12 +5,7 @@ import type { ScriptHookName } from "@defold-typescript/types";
 import { DEBUG_LAUNCHER_SOURCE, debugLaunchConfig, VSCODE_LAUNCH_CONTENT } from "./debug-launcher";
 import { CURRENT_STABLE_DEFOLD_VERSION } from "./defold-version";
 import { mergeMiseToml } from "./mise-scaffold";
-import {
-  detectScriptKinds,
-  type ScriptKind,
-  selectScriptKind,
-  selectScriptKindEntrypoint,
-} from "./script-kind";
+import { DEFAULT_TYPES_ENTRYPOINT } from "./script-kind";
 
 export interface RunInitOptions {
   readonly cwd: string;
@@ -19,7 +14,6 @@ export interface RunInitOptions {
 
 export interface RunInitResult {
   readonly written: string[];
-  readonly scriptKind: ScriptKind | null;
 }
 
 const CONFLICTING_TS_CONFIGS = [
@@ -38,12 +32,30 @@ const TSCONFIG_COMPILER_OPTIONS = {
   skipLibCheck: true,
 };
 
-const GITIGNORE_LINES = ["src/**/*.ts.script", "src/**/*.ts.script.map"];
+const GITIGNORE_LINES = [
+  "src/**/*.ts.script",
+  "src/**/*.ts.script.map",
+  "src/**/*.ts.gui_script",
+  "src/**/*.ts.gui_script.map",
+  "src/**/*.ts.render_script",
+  "src/**/*.ts.render_script.map",
+  "src/**/*.lua",
+  "src/**/*.lua.map",
+];
 
 const BIOME_JSON_CONTENT = {
   $schema: "https://biomejs.dev/schemas/2.4.15/schema.json",
   files: {
-    includes: ["src/**/*.ts", "!**/dist", "!**/node_modules", "!**/*.ts.script"],
+    includes: [
+      "src/**/*.ts",
+      "!**/dist",
+      "!**/node_modules",
+      "!**/*.ts.script",
+      "!**/*.ts.gui_script",
+      "!**/*.ts.render_script",
+      "!src/**/*.lua",
+      "!src/**/*.lua.map",
+    ],
   },
   formatter: {
     enabled: true,
@@ -76,10 +88,17 @@ const BIOME_JSON_CONTENT = {
 };
 
 const VSCODE_EXTENSIONS_CONTENT = {
-  recommendations: ["sumneko.lua", "astronachos.defold", "tomblind.local-lua-debugger-vscode"],
+  recommendations: ["tomblind.local-lua-debugger-vscode"],
   unwantedRecommendations: ["johnnymorganz.luau-lsp"],
 };
 
+const MANAGED_RECOMMENDATIONS = [
+  "tomblind.local-lua-debugger-vscode",
+  "sumneko.lua",
+  "astronachos.defold",
+];
+const MANAGED_UNWANTED = ["johnnymorganz.luau-lsp"];
+
 const VSCODE_SETTINGS_CONTENT = {
   "Lua.workspace.ignoreDir": ["src"],
 };
@@ -154,7 +173,7 @@ function inlineSnippetBody(factory: string, includeOnInput: boolean): string[] {
   return [
     `import { ${factory} } from "@defold-typescript/types";`,
     "",
-    `export const script = ${factory}({`,
+    `export default ${factory}({`,
     `  // ${HOOK_COMMENTS.init}`,
     "  init() {",
     "    return { $0 };",
@@ -173,7 +192,7 @@ function typedSnippetBody(factory: string, includeOnInput: boolean): string[] {
     "  $1",
     "};",
     "",
-    `export const script = ${factory}<Self>({`,
+    `export default ${factory}<Self>({`,
     `  // ${HOOK_COMMENTS.init}`,
     "  init(): Self {",
     "    return { $0 };",
@@ -222,23 +241,21 @@ const VSCODE_SNIPPETS_CONTENT: Record<string, VscodeSnippet> = {
   },
 };
 
-const MAIN_TS_CONTENT = `export function init(): void {
-  const start = vmath.vector3(0, 0, 0);
-  msg.post("main:/hero", "spawn", { start });
-}
-`;
+const MAIN_TS_CONTENT = `import { defineScript } from "@defold-typescript/types";
 
-const MAIN_SCRIPT_CONTENT = `function init(self) end
-function update(self, dt) end
-function on_message(self, message_id, message, sender) end
-function final(self) end
+export default defineScript({
+  init() {
+    const start = vmath.vector3(0, 0, 0);
+    return { start };
+  },
+});
 `;
 
 const MAIN_COLLECTION_CONTENT = `name: "main"
 scale_along_z: 0
 embedded_instances {
   id: "main"
-  data: "components {\\n  id: \\"main\\"\\n  component: \\"/main/main.script\\"\\n}\\n"
+  data: "components {\\n  id: \\"main\\"\\n  component: \\"/src/main.ts.script\\"\\n}\\n"
   position { x: 0.0 y: 0.0 z: 0.0 }
   rotation { x: 0.0 y: 0.0 z: 0.0 w: 1.0 }
   scale3 { x: 1.0 y: 1.0 z: 1.0 }
@@ -270,8 +287,8 @@ function typesVersionSpec(): string {
 }
 
 // @defold-typescript/types (type-only, for the editor) and @defold-typescript/cli
-// (the local bin the managed `bunx --no-install defold-typescript` mise tasks
-// resolve) both ship into the consumer. The transpiler must NOT be a direct
+// (the local bin the managed `bunx @defold-typescript/cli` mise tasks resolve
+// inside an installed project) both ship into the consumer. The transpiler must NOT be a direct
 // consumer dep — it arrives transitively through the CLI. Pin both managed deps
 // to this CLI's own version so the coordinated-release set stays in lockstep.
 export const SCAFFOLD_DEV_DEPS: Record<string, string> = {
@@ -400,6 +417,34 @@ function unionStrings(existing: unknown, additions: readonly string[]): string[]
   return out;
 }
 
+export function reconcileManagedList(
+  existing: unknown,
+  managed: readonly string[],
+  canonical: readonly string[],
+): string[] {
+  const managedSet = new Set(managed);
+  const canonicalSet = new Set(canonical);
+  const out: string[] = [];
+  const values = Array.isArray(existing)
+    ? existing.filter((value): value is string => typeof value === "string")
+    : [];
+  for (const value of values) {
+    if (out.includes(value)) {
+      continue;
+    }
+    if (managedSet.has(value) && !canonicalSet.has(value)) {
+      continue;
+    }
+    out.push(value);
+  }
+  for (const value of canonical) {
+    if (!out.includes(value)) {
+      out.push(value);
+    }
+  }
+  return out;
+}
+
 function readVscodeJson(filePath: string): Record<string, unknown> | null {
   try {
     const parsed = parseJsonc(readFileSync(filePath, "utf8"));
@@ -417,15 +462,20 @@ function writeVscodeExtensions(cwd: string, written: string[]): void {
     if (existing === null) {
       return;
     }
-    existing.recommendations = unionStrings(
+    const before = JSON.stringify(existing);
+    existing.recommendations = reconcileManagedList(
       existing.recommendations,
+      MANAGED_RECOMMENDATIONS,
       VSCODE_EXTENSIONS_CONTENT.recommendations,
     );
-    existing.unwantedRecommendations = unionStrings(
+    existing.unwantedRecommendations = reconcileManagedList(
       existing.unwantedRecommendations,
+      MANAGED_UNWANTED,
       VSCODE_EXTENSIONS_CONTENT.unwantedRecommendations,
     );
-    writeJson(filePath, existing);
+    if (JSON.stringify(existing) !== before) {
+      writeJson(filePath, existing);
+    }
     return;
   }
   mkdirSync(dir, { recursive: true });
@@ -509,16 +559,15 @@ function writeVscodeDebugLauncher(cwd: string, written: string[]): void {
   written.push(".vscode/defold-debug.ts");
 }
 
-function writeTsSurface(cwd: string, written: string[], force = false): ScriptKind | null {
+function writeTsSurface(cwd: string, written: string[], force = false): void {
   mkdirSync(path.join(cwd, "src"), { recursive: true });
   writeFileSync(path.join(cwd, "src", "main.ts"), MAIN_TS_CONTENT);
   written.push("src/main.ts");
 
-  const kinds = detectScriptKinds(cwd);
   const tsconfig = {
     compilerOptions: {
       ...TSCONFIG_COMPILER_OPTIONS,
-      types: [selectScriptKindEntrypoint(kinds)],
+      types: [DEFAULT_TYPES_ENTRYPOINT],
     },
     include: ["src/**/*.ts"],
   };
@@ -561,8 +610,6 @@ function writeTsSurface(cwd: string, written: string[], force = false): ScriptKi
   writeVscodeSnippets(cwd, written);
   writeVscodeLaunch(cwd, written);
   writeVscodeDebugLauncher(cwd, written);
-
-  return selectScriptKind(kinds);
 }
 
 export function runNewProjectInit(cwd: string, force = false): RunInitResult {
@@ -585,12 +632,10 @@ export function runNewProjectInit(cwd: string, force = false): RunInitResult {
   mkdirSync(path.join(cwd, "main"), { recursive: true });
   writeFileSync(path.join(cwd, "main", "main.collection"), MAIN_COLLECTION_CONTENT);
   written.push("main/main.collection");
-  writeFileSync(path.join(cwd, "main", "main.script"), MAIN_SCRIPT_CONTENT);
-  written.push("main/main.script");
 
-  const scriptKind = writeTsSurface(cwd, written, force);
+  writeTsSurface(cwd, written, force);
 
-  return { written, scriptKind };
+  return { written };
 }
 
 export function runInit(opts: RunInitOptions): RunInitResult {
@@ -611,6 +656,6 @@ export function runInit(opts: RunInitOptions): RunInitResult {
   }
 
   const written: string[] = [];
-  const scriptKind = writeTsSurface(cwd, written, force);
-  return { written, scriptKind };
+  writeTsSurface(cwd, written, force);
+  return { written };
 }

package/src/install-reminder.ts

@@ -0,0 +1,18 @@
+// The runner (`bunx`/`npx`/`pnpm dlx`/`yarn dlx`) sets `npm_config_user_agent`
+// with the manager as its first token; when the bin is run directly the var is
+// unset. A wrong guess only mis-advises — it never writes a lockfile — so the
+// fallback to bun (the repo's primary manager) is safe.
+export function installHint(env: NodeJS.ProcessEnv = process.env): string {
+  const agent = env.npm_config_user_agent ?? "";
+  const manager = agent.split("/")[0];
+  if (manager === "pnpm") {
+    return "pnpm install";
+  }
+  if (manager === "yarn") {
+    return "yarn install";
+  }
+  if (manager === "npm") {
+    return "npm install";
+  }
+  return "bun install";
+}