@rendotdev/rig 0.0.20 → 0.0.22

package/dist/cli-113n7c3t.js

@@ -1,513 +0,0 @@
-import {
-  SchemaRenderer
-} from "./cli-884hpkjc.js";
-import {
-  CommandIds,
-  ToolLoader,
-  createRigToolKit
-} from "./cli-f7p31fzm.js";
-import {
-  RigError,
-  RigErrors
-} from "./cli-1c7te5cg.js";
-
-// src/tools/run.ts
-import { readFile } from "node:fs/promises";
-
-// src/runtime/envelope.ts
-class EnvelopeFactory {
-  static success(params) {
-    return {
-      data: params.data,
-      errors: []
-    };
-  }
-  static error(params) {
-    return {
-      data: null,
-      errors: [
-        {
-          code: params.code,
-          message: params.message,
-          details: params.details
-        }
-      ]
-    };
-  }
-}
-
-// src/runtime/truncation.ts
-import { mkdtemp, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-var DEFAULT_TRUNCATION_MAX_BYTES = 50 * 1024;
-var DEFAULT_TRUNCATION_MAX_LINES = 2000;
-
-class TextMetrics {
-  encoder = new TextEncoder;
-  byteLength(value) {
-    return this.encoder.encode(value).byteLength;
-  }
-  lineCount(value) {
-    if (value.length === 0)
-      return 0;
-    return value.split(`
-`).length;
-  }
-}
-
-class TextHeadTruncator {
-  metrics = new TextMetrics;
-  encoder = new TextEncoder;
-  decoder = new TextDecoder;
-  truncate(value, options) {
-    const totalBytes = this.metrics.byteLength(value);
-    const totalLines = this.metrics.lineCount(value);
-    let content = value;
-    if (totalLines > options.maxLines) {
-      content = content.split(`
-`).slice(0, options.maxLines).join(`
-`);
-    }
-    if (this.metrics.byteLength(content) > options.maxBytes) {
-      content = this.decoder.decode(this.encoder.encode(content).slice(0, options.maxBytes));
-    }
-    const outputBytes = this.metrics.byteLength(content);
-    const outputLines = this.metrics.lineCount(content);
-    return {
-      content,
-      truncated: outputBytes < totalBytes || outputLines < totalLines,
-      totalBytes,
-      totalLines,
-      outputBytes,
-      outputLines
-    };
-  }
-}
-
-class OutputTempFileStore {
-  async writeJson(content) {
-    const dir = await mkdtemp(join(tmpdir(), "rig-output-"));
-    const path = join(dir, "data.json");
-    if (typeof Bun !== "undefined")
-      await Bun.write(path, `${content}
-`);
-    else
-      await writeFile(path, `${content}
-`, "utf8");
-    return path;
-  }
-}
-
-class JsonDataSerializer {
-  serialize(value) {
-    return JSON.stringify(value, null, 2) ?? "null";
-  }
-}
-
-class SizeFormatter {
-  format(bytes) {
-    if (bytes < 1024)
-      return `${bytes}B`;
-    if (bytes < 1024 * 1024)
-      return `${(bytes / 1024).toFixed(1)}KB`;
-    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-  }
-}
-
-class RigOutputTruncator {
-  options;
-  serializer = new JsonDataSerializer;
-  truncator = new TextHeadTruncator;
-  store = new OutputTempFileStore;
-  sizeFormatter = new SizeFormatter;
-  constructor(options = {}) {
-    this.options = {
-      maxBytes: options.maxBytes ?? DEFAULT_TRUNCATION_MAX_BYTES,
-      maxLines: options.maxLines ?? DEFAULT_TRUNCATION_MAX_LINES
-    };
-  }
-  async truncateData(data) {
-    const serialized = this.serializer.serialize(data);
-    const truncation = this.truncator.truncate(serialized, this.options);
-    if (!truncation.truncated)
-      return data;
-    const fullOutputPath = await this.store.writeJson(serialized);
-    const omittedBytes = truncation.totalBytes - truncation.outputBytes;
-    const omittedLines = truncation.totalLines - truncation.outputLines;
-    return {
-      truncated: true,
-      strategy: "head",
-      preview: truncation.content,
-      previewFormat: "partial-json",
-      fullOutputPath,
-      fullOutputFormat: "json",
-      maxBytes: this.options.maxBytes,
-      maxLines: this.options.maxLines,
-      totalBytes: truncation.totalBytes,
-      totalLines: truncation.totalLines,
-      shownBytes: truncation.outputBytes,
-      shownLines: truncation.outputLines,
-      omittedBytes,
-      omittedLines,
-      message: `Output truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines (${this.sizeFormatter.format(truncation.outputBytes)} of ${this.sizeFormatter.format(truncation.totalBytes)}). Full output saved to: ${fullOutputPath}`
-    };
-  }
-}
-
-// 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) {
-    const args = options.args ?? [];
-    const inputSources = [
-      Boolean(options.input),
-      Boolean(options.inputFile),
-      args.length > 0
-    ].filter(Boolean).length;
-    if (inputSources > 1) {
-      throw new RigError("INPUT_ERROR", "Use args, --input, or --input-file, not more than one.");
-    }
-    if (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}'` };
-    }
-    if (args.length > 0) {
-      const parser = new InputArgumentParser(command.input);
-      return { value: parser.parse(args), source: new InputSourceRenderer().render(args) };
-    }
-    return { value: {}, source: "--input '{}'" };
-  }
-}
-
-class InputArgumentParser {
-  schema;
-  constructor(schema) {
-    this.schema = schema;
-  }
-  parse(args) {
-    if (args.length === 1) {
-      const maybeJson = this.tryParseJson(args[0]);
-      if (maybeJson.parsed && this.shouldUseJsonValue(maybeJson.value))
-        return maybeJson.value;
-    }
-    if (args.every((arg) => arg.includes("="))) {
-      return Object.fromEntries(args.map((arg) => this.parseKeyValueArg(arg)));
-    }
-    const fields = this.inputFieldNames();
-    if (fields.length === 0) {
-      if (args.length === 1)
-        return this.parseScalar(args[0]);
-      throw new RigError("INPUT_ERROR", "This command does not declare positional input fields.", {
-        args
-      });
-    }
-    if (args.length > fields.length) {
-      throw new RigError("INPUT_ERROR", "Too many positional arguments.", {
-        args,
-        expectedFields: fields
-      });
-    }
-    return Object.fromEntries(args.map((arg, index) => [fields[index], this.parseScalar(arg)]));
-  }
-  parseKeyValueArg(arg) {
-    const separatorIndex = arg.indexOf("=");
-    const key = arg.slice(0, separatorIndex);
-    const value = arg.slice(separatorIndex + 1);
-    if (!key) {
-      throw new RigError("INPUT_ERROR", "Argument keys must not be empty.", { arg });
-    }
-    return [key, this.parseScalar(value)];
-  }
-  parseScalar(value) {
-    const maybeJson = this.tryParseJson(value);
-    return maybeJson.parsed ? maybeJson.value : value;
-  }
-  tryParseJson(value) {
-    try {
-      return { parsed: true, value: JSON.parse(value) };
-    } catch {
-      return { parsed: false };
-    }
-  }
-  shouldUseJsonValue(value) {
-    return typeof value === "object" && value !== null;
-  }
-  inputFieldNames() {
-    const jsonSchema = SchemaRenderer.toJsonSchema(this.schema);
-    if (!this.isRecord(jsonSchema) || !this.isRecord(jsonSchema.properties))
-      return [];
-    return Object.keys(jsonSchema.properties);
-  }
-  isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-  }
-}
-
-class InputSourceRenderer {
-  render(args) {
-    return args.map((arg) => this.shellArg(arg)).join(" ");
-  }
-  shellArg(value) {
-    if (/^[A-Za-z0-9_./:=@+-]+$/.test(value))
-      return value;
-    return `'${value.replaceAll("'", "'\\''")}'`;
-  }
-}
-
-class ZodErrorPresenter {
-  present(error) {
-    return {
-      ...this.flattenObject(error.flatten()),
-      issues: (error.issues ?? []).map((issue) => this.presentIssue(issue))
-    };
-  }
-  presentIssue(issue) {
-    if (!this.isRecord(issue))
-      return { message: String(issue) };
-    return Object.fromEntries(Object.entries({
-      path: Array.isArray(issue.path) ? issue.path.join(".") : "",
-      code: issue.code,
-      message: issue.message,
-      expected: issue.expected,
-      received: issue.received
-    }).filter(([, value]) => value !== undefined));
-  }
-  flattenObject(value) {
-    return this.isRecord(value) ? value : {};
-  }
-  isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-  }
-}
-
-class DryRunPresenter {
-  present(params) {
-    return {
-      dryRun: true,
-      wouldRun: false,
-      tool: params.tool,
-      command: params.command,
-      id: CommandIds.from(params.tool, params.command),
-      input: params.input,
-      commandLine: `rig run ${CommandIds.from(params.tool, params.command)} ${params.inputSource}`
-    };
-  }
-}
-
-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 { 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) {
-        throw new RigError("VALIDATION_ERROR", "Invalid input.", new ZodErrorPresenter().present(inputResult.error));
-      }
-      if (options.dryRun) {
-        const data2 = new DryRunPresenter().present({
-          tool: toolName,
-          command: commandName,
-          input: inputResult.data,
-          inputSource: input.source
-        });
-        return {
-          envelope: EnvelopeFactory.success({
-            data: await this.outputTruncator.truncateData(data2)
-          }),
-          exitCode: 0
-        };
-      }
-      const rig = createRigToolKit(this.options);
-      db = await this.databases.setup(tool);
-      const data = await command.run({
-        input: inputResult.data,
-        env: tool.env,
-        processEnv: process.env,
-        cwd: process.cwd(),
-        db: db ?? this.unavailableDatabases.create(toolName),
-        rig
-      });
-      const outputResult = command.output.safeParse(data);
-      if (!outputResult.success) {
-        throw new RigError("OUTPUT_VALIDATION_ERROR", "Command returned invalid output.", new ZodErrorPresenter().present(outputResult.error));
-      }
-      return {
-        envelope: EnvelopeFactory.success({
-          data: await this.outputTruncator.truncateData(outputResult.data)
-        }),
-        exitCode: 0
-      };
-    } catch (error) {
-      const rigError = this.asInputAwareRigError(error);
-      return {
-        envelope: EnvelopeFactory.error({
-          code: rigError.code,
-          message: rigError.message,
-          details: rigError.details
-        }),
-        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 });
-    }
-    return RigErrors.from(error);
-  }
-}
-
-export { ToolRunner };

package/dist/cron-aw908dzn.js

@@ -1,18 +0,0 @@
-import {
-  RigCronService,
-  RigCronWorker,
-  cronModuleUrl
-} from "./cli-es8j6mma.js";
-import"./cli-113n7c3t.js";
-import"./cli-884hpkjc.js";
-import"./cli-f7p31fzm.js";
-import"./cli-1hm5dxfw.js";
-import"./cli-nk194xv0.js";
-import"./cli-1c7te5cg.js";
-import"./cli-13q90bjr.js";
-import"./cli-b7jgjgy7.js";
-export {
-  cronModuleUrl,
-  RigCronWorker,
-  RigCronService
-};

package/dist/list-gqdh0m23.js

@@ -1,13 +0,0 @@
-import {
-  ToolListService
-} from "./cli-1354fmns.js";
-import"./cli-884hpkjc.js";
-import"./cli-f7p31fzm.js";
-import"./cli-1hm5dxfw.js";
-import"./cli-nk194xv0.js";
-import"./cli-1c7te5cg.js";
-import"./cli-13q90bjr.js";
-import"./cli-b7jgjgy7.js";
-export {
-  ToolListService
-};

package/dist/run-thx15p83.js

@@ -1,13 +0,0 @@
-import {
-  ToolRunner
-} from "./cli-113n7c3t.js";
-import"./cli-884hpkjc.js";
-import"./cli-f7p31fzm.js";
-import"./cli-1hm5dxfw.js";
-import"./cli-nk194xv0.js";
-import"./cli-1c7te5cg.js";
-import"./cli-13q90bjr.js";
-import"./cli-b7jgjgy7.js";
-export {
-  ToolRunner
-};