@rendotdev/rig 0.0.17 → 0.0.18

package/dist/{cli-xv4m20sx.js → cli-jbscjyqq.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-vkw9rcke.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 { existsSync as existsSync3 } 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],
@@ -14674,18 +14694,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: []
     };
   }
 }
@@ -14700,7 +14728,7 @@ class RigConfigStore {
   }
   async ensure() {
     await mkdir2(this.paths.rigDir, { recursive: true });
-    if (!existsSync2(this.paths.configPath)) {
+    if (!existsSync3(this.paths.configPath)) {
       await this.write(RigConfigDefaults.create());
     }
     const config2 = await this.read();
@@ -14737,7 +14765,7 @@ 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 mkdir2(dirname2(this.paths.configPath), { recursive: true });
     const tmpPath = `${this.paths.configPath}.tmp-${process.pid}`;
     await writeFile2(tmpPath, `${JSON.stringify(result.data, null, 2)}
 `, "utf8");
@@ -14757,4 +14785,4 @@ class RigConfigStore {
   }
 }
 
-export { exports_external, RigConfigStore };
+export { RigPackageRoot, exports_external, RigConfigStore };

package/dist/{cli-ne7ed594.js → cli-vkw9rcke.js}

@@ -22,7 +22,7 @@ class RigPaths {
     return isAbsolute(expanded) ? resolve(expanded) : resolve(process.cwd(), expanded);
   }
   get rigDir() {
-    return join(this.homeDir, ".rig");
+    return join(this.homeDir, "rig");
   }
   get configPath() {
     return join(this.rigDir, "rig.json");
@@ -42,11 +42,17 @@ class RigPaths {
   get runtimeToolTsconfigPath() {
     return join(this.runtimeDir, "tsconfig.tools.json");
   }
+  get cronDir() {
+    return join(this.rigDir, "cron");
+  }
+  cronWorkerPath(name) {
+    return join(this.cronDir, `${name}.ts`);
+  }
   get updateCheckCachePath() {
     return join(this.rigDir, "update-check.json");
   }
   get defaultBaseRegistryDir() {
-    return "~/.rig/tools";
+    return "~/rig/tools";
   }
   parentDir(pathValue) {
     return dirname(pathValue);

package/dist/{run-y66hvyxg.js → cli-yahk2r84.js}

@@ -1,20 +1,15 @@
 import {
   SchemaRenderer
-} from "./cli-dshh1cp9.js";
+} from "./cli-f4k31gtc.js";
 import {
   CommandIds,
   ToolLoader,
   createRigToolKit
-} from "./cli-7zqnqrah.js";
-import"./cli-vx11bmzr.js";
-import"./cli-xv4m20sx.js";
-import"./cli-aj56a1ja.js";
+} from "./cli-c6y9p8v9.js";
 import {
   RigError,
   RigErrors
 } from "./cli-1c7te5cg.js";
-import"./cli-ne7ed594.js";
-import"./cli-b7jgjgy7.js";
 
 // src/tools/run.ts
 import { readFile } from "node:fs/promises";
@@ -94,7 +89,11 @@ class OutputTempFileStore {
   async writeJson(content) {
     const dir = await mkdtemp(join(tmpdir(), "rig-output-"));
     const path = join(dir, "data.json");
-    await writeFile(path, `${content}
+    if (typeof Bun !== "undefined")
+      await Bun.write(path, `${content}
+`);
+    else
+      await writeFile(path, `${content}
 `, "utf8");
     return path;
   }
@@ -156,6 +155,138 @@ class RigOutputTruncator {
   }
 }
 
+// src/tools/db.ts
+import { createHash } from "node:crypto";
+import { mkdir } from "node:fs/promises";
+import { dirname, join as join2 } from "node:path";
+class MigrationChecksum {
+  digest(version, name, sql) {
+    return createHash("sha256").update(`${version}\x00${name}\x00${sql}`).digest("hex");
+  }
+}
+
+class RigDatabaseMigrator {
+  db;
+  lastVersion = 0;
+  checksums = new MigrationChecksum;
+  constructor(db) {
+    this.db = db;
+  }
+  ensureMetadata() {
+    this.db.run(`
+      create table if not exists _rig_migrations (
+        version integer primary key,
+        name text not null,
+        checksum text not null,
+        applied_at text not null
+      );
+    `);
+  }
+  migrate(version, name, sql) {
+    this.validate(version, name, sql);
+    const checksum = this.checksums.digest(version, name, sql);
+    const existing = this.existingMigration(version);
+    if (existing) {
+      this.assertExistingMigrationMatches(version, name, checksum, existing);
+      return;
+    }
+    const apply = this.db.transaction(() => {
+      this.db.run(sql);
+      this.db.query(`insert into _rig_migrations (version, name, checksum, applied_at)
+           values ($version, $name, $checksum, $appliedAt)`).run({ version, name, checksum, appliedAt: new Date().toISOString() });
+    });
+    apply();
+  }
+  validate(version, name, sql) {
+    if (!Number.isInteger(version) || version <= 0) {
+      throw new RigError("TOOL_INVALID", `Migration version must be a positive integer: ${version}`);
+    }
+    if (version <= this.lastVersion) {
+      throw new RigError("TOOL_INVALID", `Migration versions must be declared in ascending order: ${version} after ${this.lastVersion}`);
+    }
+    if (!name.trim())
+      throw new RigError("TOOL_INVALID", "Migration name must not be empty.");
+    if (!sql.trim())
+      throw new RigError("TOOL_INVALID", `Migration ${version} SQL must not be empty.`);
+    this.lastVersion = version;
+  }
+  existingMigration(version) {
+    const row = this.db.query("select name, checksum from _rig_migrations where version = ?").get(version);
+    return row ?? undefined;
+  }
+  assertExistingMigrationMatches(version, name, checksum, existing) {
+    if (existing.name === name && existing.checksum === checksum)
+      return;
+    throw new RigError("TOOL_INVALID", `Migration ${version} has changed since it was applied.`, {
+      version,
+      expected: existing,
+      actual: { name, checksum }
+    });
+  }
+}
+
+class BunSqliteModuleLoader {
+  async database() {
+    const database = globalThis.rigSqliteDatabaseForTests;
+    if (!database)
+      return this.nativeDatabase();
+    return database;
+  }
+  async nativeDatabase() {
+    const specifier = "bun:sqlite";
+    const moduleValue = await import(specifier);
+    return moduleValue.Database;
+  }
+}
+
+class RigToolDatabaseFactory {
+  sqlite = new BunSqliteModuleLoader;
+  async create(toolPath) {
+    const dbPath = this.dbPathForToolPath(toolPath);
+    await mkdir(dirname(dbPath), { recursive: true });
+    const Database = await this.sqlite.database();
+    const db = new Database(dbPath, { create: true, strict: true });
+    const migrator = new RigDatabaseMigrator(db);
+    Object.defineProperty(db, "path", { value: dbPath, enumerable: true });
+    Object.defineProperty(db, "migrate", {
+      value: (version, name, sql) => migrator.migrate(version, name, sql),
+      enumerable: true
+    });
+    db.run("PRAGMA journal_mode = WAL;");
+    migrator.ensureMetadata();
+    return db;
+  }
+  dbPathForToolPath(toolPath) {
+    return join2(dirname(toolPath), "index.sqlite");
+  }
+}
+
+class UnavailableToolDatabaseFactory {
+  create(toolName) {
+    return new Proxy({}, {
+      get() {
+        throw new RigError("TOOL_INVALID", `Tool ${toolName} must define setupDb before using context.db.`, {
+          tool: toolName
+        });
+      }
+    });
+  }
+}
+
+class ToolDatabaseService {
+  factory = new RigToolDatabaseFactory;
+  async setup(tool) {
+    if (!tool.definition.setupDb)
+      return;
+    const db = await this.factory.create(tool.path);
+    await tool.definition.setupDb(db);
+    return db;
+  }
+  dbPathForToolPath(toolPath) {
+    return this.factory.dbPathForToolPath(toolPath);
+  }
+}
+
 // src/tools/run.ts
 class RunInputReader {
   async read(command, options) {
@@ -169,8 +300,8 @@ class RunInputReader {
       throw new RigError("INPUT_ERROR", "Use args, --input, or --input-file, not more than one.");
     }
     if (options.inputFile) {
-      const raw = await readFile(options.inputFile, "utf8");
-      return { value: JSON.parse(raw), source: `--input-file ${options.inputFile}` };
+      const value = typeof Bun !== "undefined" ? await Bun.file(options.inputFile).json() : JSON.parse(await readFile(options.inputFile, "utf8"));
+      return { value, source: `--input-file ${options.inputFile}` };
     }
     if (options.input) {
       return { value: JSON.parse(options.input), source: `--input '${options.input}'` };
@@ -300,16 +431,19 @@ class DryRunPresenter {
 
 class ToolRunner {
   options;
+  databases = new ToolDatabaseService;
   loader;
   inputReader = new RunInputReader;
   outputTruncator = new RigOutputTruncator;
+  unavailableDatabases = new UnavailableToolDatabaseFactory;
   constructor(options = {}) {
     this.options = options;
     this.loader = new ToolLoader(options);
   }
   async run(toolName, commandName, options = {}) {
+    let db;
     try {
-      const { command } = await this.loader.loadCommand(toolName, commandName);
+      const { tool, command } = await this.loader.loadCommand(toolName, commandName);
       const input = await this.inputReader.read(command, options);
       const inputResult = command.input.safeParse(input.value);
       if (!inputResult.success) {
@@ -330,11 +464,13 @@ class ToolRunner {
         };
       }
       const rig = createRigToolKit(this.options);
+      db = await this.databases.setup(tool);
       const data = await command.run({
         input: inputResult.data,
-        env: process.env,
+        env: tool.env,
+        processEnv: process.env,
         cwd: process.cwd(),
-        shell: rig.shell,
+        db: db ?? this.unavailableDatabases.create(toolName),
         rig
       });
       const outputResult = command.output.safeParse(data);
@@ -357,8 +493,15 @@ class ToolRunner {
         }),
         exitCode: 1
       };
+    } finally {
+      this.closeDatabase(db);
     }
   }
+  closeDatabase(db) {
+    try {
+      db?.close(false);
+    } catch {}
+  }
   asInputAwareRigError(error) {
     if (error instanceof SyntaxError) {
       return new RigError("INPUT_ERROR", "Input JSON is invalid.", { message: error.message });
@@ -366,6 +509,5 @@ class ToolRunner {
     return RigErrors.from(error);
   }
 }
-export {
-  ToolRunner
-};
+
+export { ToolRunner };

package/dist/{config-24gwe08t.js → config-8mr59m0q.js}

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

package/dist/{create-59myk91d.js → create-9frp1c7g.js}

@@ -1,18 +1,17 @@
 import {
   ToolLoader
-} from "./cli-7zqnqrah.js";
+} from "./cli-c6y9p8v9.js";
 import {
   RigToolEntryFiles,
   ToolDiscoveryService
-} from "./cli-vx11bmzr.js";
+} from "./cli-ggk7t6dg.js";
 import {
   RigConfigStore
-} from "./cli-xv4m20sx.js";
-import"./cli-aj56a1ja.js";
+} from "./cli-jbscjyqq.js";
 import {
   RigError
 } from "./cli-1c7te5cg.js";
-import"./cli-ne7ed594.js";
+import"./cli-vkw9rcke.js";
 import"./cli-b7jgjgy7.js";
 
 // src/tools/create.ts
@@ -51,12 +50,12 @@ class ToolCreator {
   name: ${JSON.stringify(name)},
   description: "Describe what this tool does.",
   commands: {
-    example: rig.command({
+    example: rig.defineCommand({
       description: "Example command. Replace this with a real command.",
-      input: rig.input({
+      input: rig.z.object({
         text: rig.z.string().default("example"),
       }),
-      output: rig.output({
+      output: rig.z.object({
         text: rig.z.string(),
       }),
       examples: [

package/dist/cron-e6whgdf7.js

@@ -0,0 +1,18 @@
+import {
+  RigCronService,
+  RigCronWorker,
+  cronModuleUrl
+} from "./cli-0p4wnh3p.js";
+import"./cli-yahk2r84.js";
+import"./cli-f4k31gtc.js";
+import"./cli-c6y9p8v9.js";
+import"./cli-ggk7t6dg.js";
+import"./cli-jbscjyqq.js";
+import"./cli-1c7te5cg.js";
+import"./cli-vkw9rcke.js";
+import"./cli-b7jgjgy7.js";
+export {
+  cronModuleUrl,
+  RigCronWorker,
+  RigCronService
+};

package/dist/{dev-link-jpte1gq9.js → dev-link-x3hjyy3j.js}

@@ -3,7 +3,7 @@ import {
 } from "./cli-1c7te5cg.js";
 import {
   RigPaths
-} from "./cli-ne7ed594.js";
+} from "./cli-vkw9rcke.js";
 import"./cli-b7jgjgy7.js";
 
 // src/dev/dev-link.ts
@@ -29,7 +29,10 @@ class DevLinkService {
       });
     }
     await mkdir(binDir, { recursive: true });
-    await writeFile(shimPath, this.shimSource(repoRoot), "utf8");
+    if (typeof Bun !== "undefined")
+      await Bun.write(shimPath, this.shimSource(repoRoot));
+    else
+      await writeFile(shimPath, this.shimSource(repoRoot), "utf8");
     await chmod(shimPath, 493);
     return this.status(options);
   }
@@ -102,7 +105,7 @@ class DevLinkService {
     return `#!/usr/bin/env bash
 # Rig dev shim. Safe to overwrite with \`rig dev link\`.
 RIG_DEV_REPO=${JSON.stringify(repoRoot)}
-exec bun run "$RIG_DEV_REPO/src/cli.ts" "$@"
+exec bun --install=fallback run "$RIG_DEV_REPO/src/cli.ts" "$@"
 `;
   }
   async readExistingShim(shimPath) {
@@ -111,7 +114,7 @@ exec bun run "$RIG_DEV_REPO/src/cli.ts" "$@"
     const stat = await lstat(shimPath);
     if (!stat.isFile())
       return { exists: true, isRigDevShim: false, content: "" };
-    const content = await readFile(shimPath, "utf8");
+    const content = typeof Bun !== "undefined" ? await Bun.file(shimPath).text() : await readFile(shimPath, "utf8");
     return {
       exists: true,
       isRigDevShim: content.includes("Rig dev shim"),

package/dist/{discover-fd9e6j9j.js → discover-9n7b9ra2.js}

@@ -1,11 +1,10 @@
 import {
   RigToolEntryFiles,
   ToolDiscoveryService
-} from "./cli-vx11bmzr.js";
-import"./cli-xv4m20sx.js";
-import"./cli-aj56a1ja.js";
+} from "./cli-ggk7t6dg.js";
+import"./cli-jbscjyqq.js";
 import"./cli-1c7te5cg.js";
-import"./cli-ne7ed594.js";
+import"./cli-vkw9rcke.js";
 import"./cli-b7jgjgy7.js";
 export {
   ToolDiscoveryService,