@rendotdev/rig 0.0.17 → 0.0.19

package/dist/{cli-7zqnqrah.js → cli-f7p31fzm.js}

@@ -1,9 +1,9 @@
 import {
   ToolDiscoveryService
-} from "./cli-vx11bmzr.js";
+} from "./cli-1hm5dxfw.js";
 import {
   exports_external
-} from "./cli-xv4m20sx.js";
+} from "./cli-nk194xv0.js";
 import {
   RigError
 } from "./cli-1c7te5cg.js";
@@ -12,8 +12,6 @@ import {
 } from "./cli-b7jgjgy7.js";
 
 // src/tools/types.ts
-var RigSchemaRoleSymbol = Symbol.for("rig.schemaRole");
-
 class CommandIds {
   static from(tool, command) {
     return `${tool}.${command}`;
@@ -238,7 +236,7 @@ class RigCommandRunnerRuntime {
   }
   async run(options) {
     const target = this.commandTarget(options);
-    const { ToolRunner } = await import("./run-y66hvyxg.js");
+    const { ToolRunner } = await import("./run-thx15p83.js");
     const result = await new ToolRunner(this.options).run(target.tool, target.command, {
       ...this.options,
       args: options.args,
@@ -272,9 +270,7 @@ class RigToolKitFactory {
     return {
       z: exports_external,
       defineTool: (definition) => definition,
-      command: (definition) => definition,
-      input: (value) => this.schema(value, "input"),
-      output: (value) => this.schema(value, "output"),
+      defineCommand: (definition) => definition,
       run: (options) => new RigCommandRunnerRuntime(this.options).run(options),
       $: (strings, ...values) => shell.$(strings, ...values),
       args: () => new RigArgsRuntime,
@@ -282,27 +278,9 @@ class RigToolKitFactory {
       shell
     };
   }
-  schema(value, role) {
-    const schema = this.isZodSchema(value) ? value : exports_external.object(value);
-    const existingRole = schema[RigSchemaRoleSymbol];
-    if (existingRole === role)
-      return schema;
-    Object.defineProperty(schema, RigSchemaRoleSymbol, {
-      value: role,
-      configurable: false,
-      enumerable: false,
-      writable: false
-    });
-    return schema;
-  }
-  isZodSchema(value) {
-    return typeof value === "object" && value !== null && typeof value.safeParse === "function";
-  }
 }
 var rig = new RigToolKitFactory().create();
-var command = rig.command;
-var input = rig.input;
-var output = rig.output;
+var defineCommand = rig.defineCommand;
 var run = rig.run;
 var args = rig.args;
 var paths = rig.paths;
@@ -311,6 +289,9 @@ function createRigToolKit(options = {}) {
 }
 
 // src/tools/loader.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname as dirname2, join as join2 } from "node:path";
 import { pathToFileURL } from "node:url";
 class ToolDefinitionValidator {
   validateToolName(name) {
@@ -346,6 +327,14 @@ class ToolDefinitionValidator {
         expected: "non-empty string"
       });
     }
+    if (value.setupDb !== undefined && typeof value.setupDb !== "function") {
+      throw new RigError("TOOL_INVALID", `Tool ${value.name} setupDb must be a function.`, {
+        expected: "function"
+      });
+    }
+    if (value.env !== undefined) {
+      this.validateSchema(value.env, "env", value.name);
+    }
     if (!this.isRecord(value.commands)) {
       throw new RigError("TOOL_INVALID", `Tool ${value.name} needs a commands object.`, {
         expected: "object"
@@ -355,8 +344,8 @@ class ToolDefinitionValidator {
     if (entries.length === 0) {
       throw new RigError("TOOL_INVALID", `Tool ${value.name} must define at least one command.`);
     }
-    for (const [commandName, command2] of entries) {
-      this.validateCommand(commandName, command2, value.name);
+    for (const [commandName, command] of entries) {
+      this.validateCommand(commandName, command, value.name);
     }
     return value;
   }
@@ -406,15 +395,8 @@ class ToolDefinitionValidator {
   }
   validateSchema(value, role, id) {
     if (!this.hasSafeParse(value)) {
-      throw new RigError("TOOL_INVALID", `Command ${id} needs a Rig ${role} schema.`, {
-        expected: `schema created with rig.${role}(...)`
-      });
-    }
-    const actualRole = value[RigSchemaRoleSymbol];
-    if (actualRole !== role) {
-      throw new RigError("TOOL_INVALID", `Command ${id} needs a Rig ${role} schema.`, {
-        expected: `rig.${role}(...)`,
-        actual: actualRole ?? "unbranded Zod schema"
+      throw new RigError("TOOL_INVALID", `Command ${id} needs a Zod schema for ${role}.`, {
+        expected: `rig.z.object({ ... })`
       });
     }
   }
@@ -426,9 +408,90 @@ class ToolDefinitionValidator {
   }
 }
 
+class ToolEnvFileParser {
+  parse(source, path) {
+    const env = {};
+    for (const [index, line] of source.split(/\r?\n/).entries()) {
+      const parsed = this.parseLine(line, path, index + 1);
+      if (parsed)
+        env[parsed.key] = parsed.value;
+    }
+    return env;
+  }
+  parseLine(line, path, lineNumber) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      return;
+    const match = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(trimmed);
+    if (!match) {
+      throw new RigError("TOOL_INVALID", "Invalid .env line.", {
+        path,
+        line: lineNumber
+      });
+    }
+    return { key: match[1], value: this.parseValue(match[2]) };
+  }
+  parseValue(value) {
+    const trimmed = value.trim();
+    if (trimmed.length < 2)
+      return trimmed;
+    const quote = trimmed[0];
+    if (quote !== '"' && quote !== "'" || trimmed.at(-1) !== quote)
+      return trimmed;
+    const inner = trimmed.slice(1, -1);
+    if (quote === "'")
+      return inner;
+    return inner.replaceAll("\\n", `
+`).replaceAll("\\r", "\r").replaceAll("\\t", "\t").replaceAll("\\\"", '"').replaceAll("\\\\", "\\");
+  }
+}
+
+class ToolEnvLoader {
+  parser = new ToolEnvFileParser;
+  async load(tool, definition) {
+    const envPath = join2(dirname2(tool.toolPath), ".env");
+    const fileExists = await this.exists(envPath);
+    if (!definition.env) {
+      if (fileExists) {
+        throw new RigError("TOOL_INVALID", `Tool ${definition.name} has .env but no env schema.`, {
+          path: envPath
+        });
+      }
+      return {};
+    }
+    const rawEnv = fileExists ? this.parser.parse(await this.readText(envPath), envPath) : {};
+    const result = definition.env.safeParse(rawEnv);
+    if (!result.success) {
+      throw new RigError("TOOL_INVALID", `Tool ${definition.name} env is invalid.`, {
+        path: envPath,
+        errors: result.error.flatten()
+      });
+    }
+    return result.data;
+  }
+  async exists(path) {
+    const bunFile = this.bunFile();
+    if (bunFile) {
+      return bunFile(path).exists();
+    }
+    return existsSync2(path);
+  }
+  async readText(path) {
+    const bunFile = this.bunFile();
+    if (bunFile)
+      return bunFile(path).text();
+    return readFile(path, "utf8");
+  }
+  bunFile() {
+    const candidate = globalThis.Bun?.file;
+    return typeof candidate === "function" ? candidate : undefined;
+  }
+}
+
 class ToolLoader {
   discovery;
   validator;
+  envLoader = new ToolEnvLoader;
   constructor(options = {}) {
     this.discovery = new ToolDiscoveryService(options);
     this.validator = new ToolDefinitionValidator;
@@ -453,7 +516,8 @@ class ToolLoader {
     const moduleRecord = moduleValue;
     const definitionValue = await this.evaluateModuleDefault(moduleRecord.default, tool.name);
     const definition = this.validator.validateToolDefinition(definitionValue, tool.name);
-    return { name: definition.name, path: tool.toolPath, definition };
+    const env = await this.envLoader.load(tool, definition);
+    return { name: definition.name, path: tool.toolPath, env, definition };
   }
   async evaluateModuleDefault(value, toolName) {
     const awaitedValue = await Promise.resolve(value);
@@ -475,15 +539,15 @@ class ToolLoader {
   async loadCommand(toolName, commandName) {
     const tool = await this.load(toolName);
     this.validator.validateCommandName(commandName);
-    const command2 = tool.definition.commands[commandName];
-    if (!command2) {
+    const command = tool.definition.commands[commandName];
+    if (!command) {
       throw new RigError("COMMAND_NOT_FOUND", `Command not found: ${CommandIds.from(toolName, commandName)}`, {
         tool: toolName,
         command: commandName,
         available: Object.keys(tool.definition.commands)
       });
     }
-    return { tool, commandName, command: command2 };
+    return { tool, commandName, command };
   }
 }
 

package/dist/{cli-xv4m20sx.js → cli-nk194xv0.js}

@@ -1,25 +1,71 @@
-import {
-  RigPackageRoot
-} from "./cli-aj56a1ja.js";
 import {
   RigError
 } from "./cli-1c7te5cg.js";
 import {
   RigPaths
-} from "./cli-ne7ed594.js";
+} from "./cli-13q90bjr.js";
 import {
   __export
 } from "./cli-b7jgjgy7.js";
 
 // src/config/config.ts
-import { mkdir as mkdir2, readFile as readFile2, rename, writeFile as writeFile2 } from "node:fs/promises";
-import { existsSync as existsSync2 } from "node:fs";
-import { dirname } from "node:path";
+import { mkdir as mkdir3, readFile as readFile3, rename as rename2, writeFile as writeFile3 } from "node:fs/promises";
+import { existsSync as existsSync4 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
 
 // src/runtime/support.ts
-import { existsSync } from "node:fs";
+import { existsSync as existsSync2 } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { join as join2 } from "node:path";
+
+// src/runtime/package-root.ts
+import { existsSync, realpathSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+class RigPackageRoot {
+  static find(metaUrl) {
+    if (process.env.RIG_PACKAGE_ROOT)
+      return resolve(process.env.RIG_PACKAGE_ROOT);
+    const argvRoot = this.fromEntrypoint(process.argv[1]);
+    if (argvRoot)
+      return argvRoot;
+    const execRoot = this.fromEntrypoint(process.execPath);
+    if (execRoot)
+      return execRoot;
+    if (this.isBunBinary(metaUrl))
+      return dirname(process.execPath);
+    return join(dirname(fileURLToPath(metaUrl)), "..", "..");
+  }
+  static packageFile(metaUrl, ...parts) {
+    return join(this.find(metaUrl), ...parts);
+  }
+  static isBunBinary(metaUrl) {
+    return metaUrl.includes("$bunfs") || metaUrl.includes("~BUN") || metaUrl.includes("%7EBUN");
+  }
+  static fromEntrypoint(entrypoint) {
+    if (!entrypoint)
+      return;
+    const resolved = this.safeRealpath(entrypoint);
+    if (!resolved)
+      return;
+    const parent = dirname(resolved);
+    const parentName = basename(parent);
+    if (parentName === "src" || parentName === "dist")
+      return dirname(parent);
+    return;
+  }
+  static safeRealpath(pathValue) {
+    try {
+      return realpathSync(pathValue);
+    } catch {
+      const absolute = resolve(pathValue);
+      return existsSync(absolute) ? absolute : undefined;
+    }
+  }
+}
+
+// src/runtime/support.ts
 class RuntimeSupport {
   paths;
   constructor(options = {}) {
@@ -37,7 +83,7 @@ class RuntimeSupport {
   }
   async ensureRegistryTsconfig(registryDir) {
     await mkdir(registryDir, { recursive: true });
-    const tsconfigPath = join(registryDir, "tsconfig.json");
+    const tsconfigPath = join2(registryDir, "tsconfig.json");
     const content = this.registryTsconfigSource();
     const existing = await this.readTextIfExists(tsconfigPath);
     if (existing !== undefined && !existing.startsWith("// Generated by Rig."))
@@ -62,7 +108,7 @@ class RuntimeSupport {
         return;
       return file.text();
     }
-    if (!existsSync(path))
+    if (!existsSync2(path))
       return;
     return readFile(path, "utf8");
   }
@@ -87,7 +133,6 @@ import type { RigToolDefinition, RigToolFactory, RigToolKit } from "./types";
 import * as zodModule from ${JSON.stringify(zodImport)};
 
 export const z: typeof zodNamespace = (zodModule as any).z ?? zodModule;
-export const rigSchemaRoleSymbol = Symbol.for("rig.schemaRole");
 
 class RigPathRuntime {
   home() { return homedir(); }
@@ -193,30 +238,12 @@ class RigCommandRunnerRuntime {
   }
 }
 
-function isZodSchema(value) {
-  return typeof value === "object" && value !== null && typeof value.safeParse === "function";
-}
-
-function schema(value, role) {
-  const result = isZodSchema(value) ? value : z.object(value);
-  if (result[rigSchemaRoleSymbol] === role) return result;
-  Object.defineProperty(result, rigSchemaRoleSymbol, {
-    value: role,
-    configurable: false,
-    enumerable: false,
-    writable: false,
-  });
-  return result;
-}
-
 const rigShell = new RigShellRuntime();
 
 export const rig: RigToolKit = {
   z,
   defineTool: (definition) => definition,
-  command: (definition) => definition,
-  input: (value) => schema(value, "input"),
-  output: (value) => schema(value, "output"),
+  defineCommand: (definition) => definition,
   run: (options) => new RigCommandRunnerRuntime().run(options),
   $: (strings, ...values) => rigShell.$(strings, ...values),
   args: () => new RigArgsRuntime(),
@@ -237,24 +264,10 @@ export class RigTool {
   }
   typesSource() {
     return `// Generated by Rig. Safe to overwrite.
+import type { Database } from "bun:sqlite";
 import type { z } from "zod";
 
-declare const RigInputSchemaBrand: unique symbol;
-declare const RigOutputSchemaBrand: unique symbol;
-
-export type RigInputSchema<T extends z.ZodTypeAny = z.ZodTypeAny> = T & {
-  readonly [RigInputSchemaBrand]: T;
-};
-
-export type RigOutputSchema<T extends z.ZodTypeAny = z.ZodTypeAny> = T & {
-  readonly [RigOutputSchemaBrand]: T;
-};
-
-export type RigSchemaFromValue<T extends z.ZodTypeAny | z.ZodRawShape> = T extends z.ZodTypeAny
-  ? T
-  : T extends z.ZodRawShape
-    ? z.ZodObject<T>
-    : never;
+export type RigSchema = z.ZodTypeAny;
 
 export type RigShellOptions = {
   cwd?: string;
@@ -300,11 +313,17 @@ export type RigRunOptions = {
   dryRun?: boolean;
 };
 
-export type RigToolRunContext<Input> = {
+export type RigToolDatabase = Database & {
+  readonly path: string;
+  migrate(version: number, name: string, sql: string): void;
+};
+
+export type RigToolRunContext<Input, Env = unknown> = {
   input: Input;
-  env: NodeJS.ProcessEnv;
+  env: Env;
+  processEnv: NodeJS.ProcessEnv;
   cwd: string;
-  shell: RigShell;
+  db: RigToolDatabase;
   rig: RigToolKit;
 };
 
@@ -316,28 +335,29 @@ export type RigToolExample<Input = any, Output = any> = {
 };
 
 export type RigCommandDefinition<
-  Input extends RigInputSchema = RigInputSchema,
-  Output extends RigOutputSchema = RigOutputSchema,
+  Input extends RigSchema = RigSchema,
+  Output extends RigSchema = RigSchema,
+  Env = unknown,
 > = {
   description: string;
   input: Input;
   output: Output;
   examples?: RigToolExample<z.input<Input>, z.output<Output>>[];
-  run: (ctx: RigToolRunContext<z.output<Input>>) => z.input<Output> | Promise<z.input<Output>>;
+  run: (ctx: RigToolRunContext<z.output<Input>, Env>) => z.input<Output> | Promise<z.input<Output>>;
 };
 
-export type RigToolDefinition = {
+export type RigToolDefinition<Env extends RigSchema = RigSchema> = {
   name: string;
   description: string;
-  commands: Record<string, RigCommandDefinition>;
+  env?: Env;
+  setupDb?: (db: RigToolDatabase) => void | Promise<void>;
+  commands: Record<string, RigCommandDefinition<RigSchema, RigSchema, z.output<Env>>>;
 };
 
 export type RigToolKit = {
   z: typeof z;
   defineTool<T extends RigToolDefinition>(definition: T): T;
-  command<I extends RigInputSchema, O extends RigOutputSchema>(definition: RigCommandDefinition<I, O>): RigCommandDefinition<I, O>;
-  input<T extends z.ZodTypeAny | z.ZodRawShape>(value: T): RigInputSchema<RigSchemaFromValue<T>>;
-  output<T extends z.ZodTypeAny | z.ZodRawShape>(value: T): RigOutputSchema<RigSchemaFromValue<T>>;
+  defineCommand<I extends RigSchema, O extends RigSchema>(definition: RigCommandDefinition<I, O>): RigCommandDefinition<I, O>;
   run<T = unknown>(options: RigRunOptions): Promise<T>;
   $(strings: TemplateStringsArray, ...values: unknown[]): Promise<RigShellResult>;
   args(): RigArgBuilder;
@@ -375,10 +395,10 @@ ${JSON.stringify({
         jsx: "preserve",
         lib: ["ES2023", "DOM"],
         types: ["bun"],
-        typeRoots: [join(this.repoRoot(), "node_modules/@types")],
+        typeRoots: [join2(this.repoRoot(), "node_modules/@types")],
         baseUrl: this.repoRoot(),
         paths: {
-          zod: [join(this.repoRoot(), "node_modules/zod/index.d.ts")]
+          zod: [join2(this.repoRoot(), "node_modules/zod/index.d.ts")]
         }
       },
       files: [this.paths.runtimeGlobalsPath, this.paths.runtimeTypesPath],
@@ -397,6 +417,100 @@ ${JSON.stringify({
   }
 }
 
+// src/config/migration.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { mkdir as mkdir2, readdir, readFile as readFile2, rename, rm, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+
+class RigDirectoryMigrationService {
+  paths;
+  constructor(paths) {
+    this.paths = paths;
+  }
+  async migrateIfNeeded() {
+    const legacyDir = this.paths.legacyRigDir;
+    const currentDir = this.paths.rigDir;
+    if (!await this.hasLegacyState(legacyDir))
+      return;
+    const currentExists = existsSync3(currentDir);
+    if (currentExists && !await this.canReplaceCurrentDirectory(currentDir)) {
+      return {
+        status: "manual",
+        legacyDir,
+        currentDir,
+        configUpdated: false,
+        reason: "Rig found data in both the old and new folders."
+      };
+    }
+    if (currentExists)
+      await rm(currentDir, { recursive: true, force: true });
+    await mkdir2(this.paths.homeDir, { recursive: true });
+    await rename(legacyDir, currentDir);
+    return {
+      status: "migrated",
+      legacyDir,
+      currentDir,
+      configUpdated: await this.rewriteMigratedConfig()
+    };
+  }
+  async hasLegacyState(legacyDir) {
+    return await this.directoryExists(legacyDir) && (existsSync3(join3(legacyDir, "rig.json")) || existsSync3(join3(legacyDir, "tools")));
+  }
+  async canReplaceCurrentDirectory(currentDir) {
+    return await this.hasDefaultCurrentConfig(currentDir) && await this.hasEmptyGeneratedRegistry(currentDir) && await this.hasEmptyCronDirectory(currentDir) && await this.hasOnlyGeneratedCurrentEntries(currentDir);
+  }
+  async hasDefaultCurrentConfig(currentDir) {
+    try {
+      const parsed = JSON.parse(await readFile2(join3(currentDir, "rig.json"), "utf8"));
+      return parsed.version === 1 && parsed.baseRegistryDir === this.paths.defaultBaseRegistryDir && Array.isArray(parsed.customRegistries) && parsed.customRegistries.length === 0 && (parsed.cronJobs === undefined || Array.isArray(parsed.cronJobs) && parsed.cronJobs.length === 0);
+    } catch {
+      return false;
+    }
+  }
+  async hasEmptyGeneratedRegistry(currentDir) {
+    const toolsDir = join3(currentDir, "tools");
+    if (!await this.directoryExists(toolsDir))
+      return true;
+    const entries = await this.visibleEntries(toolsDir);
+    return entries.every((entry) => entry === "tsconfig.json");
+  }
+  async hasEmptyCronDirectory(currentDir) {
+    const cronDir = join3(currentDir, "cron");
+    if (!await this.directoryExists(cronDir))
+      return true;
+    return (await this.visibleEntries(cronDir)).length === 0;
+  }
+  async hasOnlyGeneratedCurrentEntries(currentDir) {
+    const entries = await this.visibleEntries(currentDir);
+    return entries.every((entry) => ["rig.json", "runtime", "tools", "update-check.json", "cron"].includes(entry));
+  }
+  async rewriteMigratedConfig() {
+    const configPath = this.paths.configPath;
+    if (!existsSync3(configPath))
+      return false;
+    const parsed = JSON.parse(await readFile2(configPath, "utf8"));
+    if (!this.isLegacyBaseRegistry(parsed.baseRegistryDir))
+      return false;
+    parsed.baseRegistryDir = this.paths.defaultBaseRegistryDir;
+    await writeFile2(configPath, `${JSON.stringify(parsed, null, 2)}
+`, "utf8");
+    return true;
+  }
+  isLegacyBaseRegistry(value) {
+    return typeof value === "string" && (value === this.paths.legacyDefaultBaseRegistryDir || this.paths.resolve(value) === join3(this.paths.legacyRigDir, "tools"));
+  }
+  async visibleEntries(path) {
+    return (await readdir(path)).filter((entry) => entry !== ".DS_Store");
+  }
+  async directoryExists(path) {
+    try {
+      return (await stat(path)).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+}
+
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -14674,18 +14788,26 @@ function date4(params) {
 // node_modules/zod/v4/classic/external.js
 config(en_default());
 // src/config/schema.ts
+var RigCronJobSchema = exports_external.object({
+  name: exports_external.string().regex(/^[A-Za-z0-9_-]+$/),
+  command: exports_external.string().min(1),
+  schedule: exports_external.string().min(1),
+  input: exports_external.unknown().optional()
+});
 var RigConfigSchema = exports_external.object({
   version: exports_external.literal(1),
   baseRegistryDir: exports_external.string().min(1),
-  customRegistries: exports_external.array(exports_external.string())
+  customRegistries: exports_external.array(exports_external.string()),
+  cronJobs: exports_external.array(RigCronJobSchema).default([])
 });
 
 class RigConfigDefaults {
   static create() {
     return {
       version: 1,
-      baseRegistryDir: "~/.rig/tools",
-      customRegistries: []
+      baseRegistryDir: "~/rig/tools",
+      customRegistries: [],
+      cronJobs: []
     };
   }
 }
@@ -14694,25 +14816,30 @@ class RigConfigDefaults {
 class RigConfigStore {
   paths;
   runtimeSupport;
+  migration;
   constructor(options = {}) {
     this.paths = new RigPaths(options);
     this.runtimeSupport = new RuntimeSupport(options);
   }
+  migrationResult() {
+    return this.migration;
+  }
   async ensure() {
-    await mkdir2(this.paths.rigDir, { recursive: true });
-    if (!existsSync2(this.paths.configPath)) {
+    this.migration = await new RigDirectoryMigrationService(this.paths).migrateIfNeeded();
+    await mkdir3(this.paths.rigDir, { recursive: true });
+    if (!existsSync4(this.paths.configPath)) {
       await this.write(RigConfigDefaults.create());
     }
     const config2 = await this.read();
     const registries2 = this.registryEntries(config2);
-    await mkdir2(this.resolvedBaseRegistry(config2), { recursive: true });
+    await mkdir3(this.resolvedBaseRegistry(config2), { recursive: true });
     await this.runtimeSupport.ensure(registries2.map((registry2) => registry2.path));
     return config2;
   }
   async read() {
     let raw;
     try {
-      raw = await readFile2(this.paths.configPath, "utf8");
+      raw = await readFile3(this.paths.configPath, "utf8");
     } catch (error51) {
       throw new RigError("CONFIG_INVALID", `Could not read config at ${this.paths.configPath}.`, {
         error: error51
@@ -14737,11 +14864,11 @@ class RigConfigStore {
     if (!result.success) {
       throw new RigError("CONFIG_INVALID", "Rig config is invalid.", result.error.flatten());
     }
-    await mkdir2(dirname(this.paths.configPath), { recursive: true });
+    await mkdir3(dirname2(this.paths.configPath), { recursive: true });
     const tmpPath = `${this.paths.configPath}.tmp-${process.pid}`;
-    await writeFile2(tmpPath, `${JSON.stringify(result.data, null, 2)}
+    await writeFile3(tmpPath, `${JSON.stringify(result.data, null, 2)}
 `, "utf8");
-    await rename(tmpPath, this.paths.configPath);
+    await rename2(tmpPath, this.paths.configPath);
   }
   resolvedBaseRegistry(config2) {
     return this.paths.resolve(config2.baseRegistryDir || this.paths.defaultBaseRegistryDir);
@@ -14757,4 +14884,4 @@ class RigConfigStore {
   }
 }
 
-export { exports_external, RigConfigStore };
+export { RigPackageRoot, exports_external, RigConfigStore };

package/dist/{cli-mswdavqx.js → cli-zgw1jbeg.js}

@@ -1,13 +1,13 @@
 import {
   SchemaRenderer
-} from "./cli-dshh1cp9.js";
+} from "./cli-884hpkjc.js";
 import {
   CommandIds,
   ToolLoader
-} from "./cli-7zqnqrah.js";
+} from "./cli-f7p31fzm.js";
 import {
   ToolDiscoveryService
-} from "./cli-vx11bmzr.js";
+} from "./cli-1hm5dxfw.js";
 
 // src/tools/list.ts
 class CommandRunExampleRenderer {

package/dist/{config-24gwe08t.js → config-20f90shh.js}

@@ -1,9 +1,8 @@
 import {
   RigConfigStore
-} from "./cli-xv4m20sx.js";
-import"./cli-aj56a1ja.js";
+} from "./cli-nk194xv0.js";
 import"./cli-1c7te5cg.js";
-import"./cli-ne7ed594.js";
+import"./cli-13q90bjr.js";
 import"./cli-b7jgjgy7.js";
 export {
   RigConfigStore