diff --git a/package.json b/package.json index bc2f377..eda1141 100644 --- a/package.json +++ b/package.json @@ -12,7 +12,7 @@ "url": "git+https://github.com/rendotdev/rig.git" }, "bin": { - "rig": "dist/rig.mjs" + "rig": "dist/bin.mjs" }, "files": [ "dist/**/*", diff --git a/scripts/lib/benchmark.ts b/scripts/lib/benchmark.ts index ee73be1..cb3bec4 100644 --- a/scripts/lib/benchmark.ts +++ b/scripts/lib/benchmark.ts @@ -2,11 +2,14 @@ import { mkdir, mkdtemp, rm } from "node:fs/promises"; import { tmpdir } from "node:os"; import { join } from "node:path"; +type BenchmarkRuntime = "bun" | "node"; + class BenchmarkCommandClass { constructor( readonly name: string, readonly args: string[], readonly env: Record = {}, + readonly p50BudgetMs: Partial> = {}, ) {} } @@ -25,13 +28,13 @@ class RigBenchmarkRunnerClass { private readonly warmups = 3, ) {} - async run(command: BenchmarkCommandClass): Promise { - for (let index = 0; index < this.warmups; index++) this.spawn(command); + async run(command: BenchmarkCommandClass, runtime: BenchmarkRuntime): Promise { + for (let index = 0; index < this.warmups; index++) this.spawn(command, runtime); const times: number[] = []; for (let index = 0; index < this.iterations; index++) { const started = performance.now(); - this.spawn(command); + this.spawn(command, runtime); times.push(performance.now() - started); } @@ -45,30 +48,37 @@ class RigBenchmarkRunnerClass { }; } - spawn(command: BenchmarkCommandClass): void { + spawn(command: BenchmarkCommandClass, runtime: BenchmarkRuntime): void { + const executable = runtime === "bun" ? process.execPath : "node"; const result = Bun.spawnSync({ - cmd: ["node", this.entrypoint, ...command.args], + cmd: [executable, this.entrypoint, ...command.args], env: { ...process.env, ...command.env }, stdout: "pipe", stderr: "pipe", }); if (result.exitCode !== 0) { - throw new Error(`${command.name} failed: ${result.stderr.toString()}`); + throw new Error(`${command.name} failed under ${runtime}: ${result.stderr.toString()}`); } } } class BenchmarkReporterClass { - print(result: BenchmarkResult): void { + print(result: BenchmarkResult, runtime: BenchmarkRuntime, budgetMs?: number): void { + const budget = budgetMs === undefined ? "" : ` budget=${budgetMs.toFixed(0)}ms`; console.log( - `${result.name.padEnd(22)} min=${result.min.toFixed(1)}ms p50=${result.p50.toFixed(1)}ms p95=${result.p95.toFixed(1)}ms mean=${result.mean.toFixed(1)}ms`, + `${result.name.padEnd(28)} min=${result.min.toFixed(1)}ms p50=${result.p50.toFixed(1)}ms p95=${result.p95.toFixed(1)}ms mean=${result.mean.toFixed(1)}ms${budget}`, ); + if (budgetMs !== undefined && result.p50 > budgetMs && process.env.RIG_BENCH_ENFORCE !== "0") { + throw new Error( + `${result.name} exceeded its ${runtime} p50 budget: ${result.p50.toFixed(1)}ms > ${budgetMs.toFixed(1)}ms`, + ); + } } } export class RigBenchmarkSuiteClass { - private readonly entrypoint = process.env.RIG_BENCH_ENTRY ?? "dist/rig.mjs"; + private readonly entrypoint = process.env.RIG_BENCH_ENTRY ?? "dist/bin.mjs"; private readonly iterations = Number(process.env.RIG_BENCH_ITERATIONS ?? 20); private readonly runner = new RigBenchmarkRunnerClass(this.entrypoint, this.iterations); private readonly reporter = new BenchmarkReporterClass(); @@ -76,58 +86,118 @@ export class RigBenchmarkSuiteClass { async run(): Promise { const home = await mkdtemp(join(tmpdir(), "rig-bench-home-")); try { + const environment = this.environment(home); this.runner.spawn( - new BenchmarkCommandClass("setup", ["create", "sample"], { - RIG_HOME: home, - RIG_AGENT_SYNC: "0", - }), + new BenchmarkCommandClass("setup", ["create", "sample"], environment), + "bun", ); - await this.createNestedBenchmarkTools(home); - - const commands = [ - new BenchmarkCommandClass("config path", ["config", "path"], { - RIG_HOME: home, - RIG_AGENT_SYNC: "0", - }), - new BenchmarkCommandClass("list", ["list"], { - RIG_HOME: home, - RIG_AGENT_SYNC: "0", - }), - new BenchmarkCommandClass("help command", ["help", "sample.example"], { - RIG_HOME: home, - RIG_AGENT_SYNC: "0", - }), - new BenchmarkCommandClass("run command", ["run", "sample.example", "Agent"], { - RIG_HOME: home, - RIG_AGENT_SYNC: "0", - }), - new BenchmarkCommandClass( - "nested run (50)", - ["run", "caller.call", "--input", JSON.stringify({ count: 50 })], - { RIG_HOME: home, RIG_AGENT_SYNC: "0" }, - ), - ]; - - if (process.env.RIG_BENCH_TYPECHECK === "1") { - commands.push( - new BenchmarkCommandClass("typecheck", ["typecheck", "sample"], { - RIG_HOME: home, - RIG_AGENT_SYNC: "0", - }), - ); - } + await Promise.all([ + this.createNestedBenchmarkTools(home), + this.createCollectionBenchmarkTool(home), + this.createLoggingBenchmarkTool(home), + this.createSearchBenchmarkTools(home), + ]); + const commands = this.commands(environment); console.log(`Entrypoint: ${this.entrypoint}`); console.log(`Iterations: ${this.iterations}`); - await commands.reduce(async (previous, command) => { - await previous; - this.reporter.print(await this.runner.run(command)); + await this.runtimes().reduce(async (previousRuntime, runtime) => { + await previousRuntime; + console.log(`\nRuntime: ${runtime}`); + await commands.reduce(async (previousCommand, command) => { + await previousCommand; + this.reporter.print( + await this.runner.run(command, runtime), + runtime, + command.p50BudgetMs[runtime], + ); + }, Promise.resolve()); }, Promise.resolve()); } finally { await rm(home, { recursive: true, force: true }); } } + private commands(environment: Record): BenchmarkCommandClass[] { + const searchToolCount = this.searchToolCount(); + const commands = [ + new BenchmarkCommandClass("config path", ["config", "path"], environment, { + bun: 60, + node: 130, + }), + new BenchmarkCommandClass(`list (${searchToolCount + 5} tools)`, ["list"], environment, { + bun: 70 + searchToolCount * 0.25, + node: 150 + searchToolCount * 0.3, + }), + new BenchmarkCommandClass( + `find (${searchToolCount} tools)`, + ["find", "resize local image width"], + environment, + { bun: 80 + searchToolCount * 0.3, node: 160 + searchToolCount * 0.4 }, + ), + new BenchmarkCommandClass("help command", ["help", "sample.example"], environment, { + bun: 90, + node: 150, + }), + new BenchmarkCommandClass("run command", ["run", "sample.example", "Agent"], environment, { + bun: 100, + node: 180, + }), + new BenchmarkCommandClass( + "nested run (50)", + ["run", "caller.call", "--input", JSON.stringify({ count: 50 })], + environment, + { bun: 110, node: 190 }, + ), + new BenchmarkCommandClass( + "collection unused (1000)", + ["run", "collection-bench.noop"], + environment, + { bun: 100, node: 180 }, + ), + new BenchmarkCommandClass( + "collection count (1000)", + ["run", "collection-bench.count"], + environment, + { bun: 130, node: 230 }, + ), + new BenchmarkCommandClass( + "structured logs (1000)", + ["run", "logging-bench.write", "1000"], + { ...environment, RIG_LOG: "1" }, + { bun: 120, node: 200 }, + ), + ]; + + if (process.env.RIG_BENCH_TYPECHECK === "1") { + commands.push(new BenchmarkCommandClass("typecheck", ["typecheck", "sample"], environment)); + } + return commands; + } + + private environment(home: string): Record { + return { + RIG_HOME: home, + RIG_AGENT_SYNC: "0", + RIG_UPDATE_CHECK: "0", + RIG_LOG: "0", + }; + } + + private runtimes(): BenchmarkRuntime[] { + const requested = (process.env.RIG_BENCH_RUNTIMES ?? "bun,node") + .split(",") + .map((runtime) => runtime.trim()) + .filter(Boolean); + const invalid = requested.find((runtime) => runtime !== "bun" && runtime !== "node"); + if (invalid) throw new Error(`Unsupported benchmark runtime: ${invalid}`); + return [...new Set(requested)] as BenchmarkRuntime[]; + } + + private searchToolCount(): number { + return Number(process.env.RIG_BENCH_TOOLS ?? 100); + } + private async createNestedBenchmarkTools(home: string): Promise { const toolsDir = join(home, "rig", "tools"); const calleeDir = join(toolsDir, "callee"); @@ -140,7 +210,6 @@ export class RigBenchmarkSuiteClass { Bun.write( join(calleeDir, "index.rig.ts"), `export default (rig) => rig.defineTool({ - name: "callee", description: "Nested benchmark callee.", commands: { read: rig.defineCommand({ @@ -156,7 +225,6 @@ export class RigBenchmarkSuiteClass { Bun.write( join(callerDir, "index.rig.ts"), `export default (rig) => rig.defineTool({ - name: "caller", description: "Nested benchmark caller.", commands: { call: rig.defineCommand({ @@ -177,4 +245,88 @@ export class RigBenchmarkSuiteClass { ), ]); } + + private async createCollectionBenchmarkTool(home: string): Promise { + const toolDir = join(home, "rig", "tools", "collection-bench"); + await Bun.write( + join(toolDir, "index.rig.ts"), + `export default (rig) => rig.defineTool({ + description: "Collection benchmark tool.", + collections: { documents: {} }, + commands: { + noop: rig.defineCommand({ + description: "Return without using collections.", + input: rig.z.object({}), + output: rig.z.number(), + run: () => 1, + }), + count: rig.defineCommand({ + description: "Count collection entries.", + input: rig.z.object({}), + output: rig.z.number(), + run: (context) => context.collections.documents.count(), + }), + }, +}); +`, + ); + await Promise.all( + Array.from({ length: 1_000 }, (_, index) => + Bun.write( + join(toolDir, "documents", `${index}.md`), + `---\nvalue: ${index}\n---\n\nBenchmark document ${index}.\n`, + ), + ), + ); + } + + private async createLoggingBenchmarkTool(home: string): Promise { + await Bun.write( + join(home, "rig", "tools", "logging-bench", "index.rig.ts"), + `export default (rig) => rig.defineTool({ + description: "Logging benchmark tool.", + commands: { + write: rig.defineCommand({ + description: "Write structured log records.", + input: rig.z.object({ count: rig.z.coerce.number() }), + output: rig.z.number(), + run: (context) => { + for (let index = 0; index < context.input.count; index++) { + context.log.info({ index }, "Benchmark log record."); + } + return context.input.count; + }, + }), + }, +}); +`, + ); + } + + private async createSearchBenchmarkTools(home: string): Promise { + await Promise.all( + Array.from({ length: this.searchToolCount() }, (_, index) => { + const name = `search-${index}`; + return Bun.write( + join(home, "rig", "tools", name, "index.rig.ts"), + `export default (rig) => rig.defineTool({ + description: "Resize, sharpen, and inspect local image documents.", + commands: { + convert: rig.defineCommand({ + description: "Convert image ${index} with width, quality, and output format options.", + input: rig.z.object({ + input: rig.z.string().describe("Local image path"), + width: rig.z.number().optional(), + format: rig.z.string().optional(), + }), + output: rig.z.string(), + run: (context) => context.input.input, + }), + }, +}); +`, + ); + }), + ); + } } diff --git a/scripts/lib/smoke.ts b/scripts/lib/smoke.ts index b60b6aa..62fb1f0 100644 --- a/scripts/lib/smoke.ts +++ b/scripts/lib/smoke.ts @@ -3,7 +3,7 @@ import { tmpdir } from "node:os"; import { join } from "node:path"; export class SmokeScriptClass { - private readonly cliPath = join(import.meta.dir, "..", "..", "dist", "rig.mjs"); + private readonly cliPath = join(import.meta.dir, "..", "..", "dist", "bin.mjs"); private home = ""; async run(): Promise { diff --git a/src/application/cli/cli-application.ts b/src/application/cli/cli-application.ts index 163fae6..37007b4 100644 --- a/src/application/cli/cli-application.ts +++ b/src/application/cli/cli-application.ts @@ -3,7 +3,6 @@ import type { Command } from "commander"; import type { RigDirectoryMigrationResult } from "../../config/migration"; import type { PathOptions } from "../../config/paths"; import { rigErrors } from "../../errors/RigError"; -import { RigLoggerFactoryClass } from "../../runtime/logger"; import { rigPackageRoot } from "../../runtime/package-root"; import { commandTargets } from "../../tools/identifiers"; import { RunPipelineContextServiceClass } from "./pipeline-context"; @@ -532,6 +531,7 @@ export class CliApplicationClass { const registries = configStore.registryEntries(config); const currentVersion = this.version(); + const { RigLoggerFactoryClass } = await import("../../runtime/logger"); new RigLoggerFactoryClass(options) .app("cli") .info({ version: currentVersion, tools: tools.length }, "Default status rendered."); @@ -590,6 +590,7 @@ export class CliApplicationClass { const registries = configStore.registryEntries(config); const tools = await new ToolDiscoveryServiceClass(options).discover(); + const { RigLoggerFactoryClass } = await import("../../runtime/logger"); new RigLoggerFactoryClass(options) .app("doctor") .info({ registries: registries.length, tools: tools.length }, "Doctor check completed."); diff --git a/src/bin.ts b/src/bin.ts new file mode 100644 index 0000000..840b2da --- /dev/null +++ b/src/bin.ts @@ -0,0 +1,8 @@ +#!/usr/bin/env bun +import { CliCompositionRootClass } from "./application/cli/composition-root"; +import { isCliEntrypoint } from "./application/cli/runtime-bootstrap"; + +/* v8 ignore next 3 */ +if (isCliEntrypoint(import.meta.url)) { + await new CliCompositionRootClass({ metaUrl: import.meta.url, argv: process.argv }, {}).run(); +} diff --git a/src/collections/application/tool-collection.ts b/src/collections/application/tool-collection.ts index 748a1f5..747ffd4 100644 --- a/src/collections/application/tool-collection.ts +++ b/src/collections/application/tool-collection.ts @@ -421,16 +421,6 @@ class SqliteCollectionIndexClass implements CollectionIndexInterface { } private validate(): void { - const integrityRows = this.db!.query("PRAGMA quick_check;").all() as Array< - Record - >; - const integrityResults = integrityRows.flatMap((row) => Object.values(row)); - if (integrityResults.length !== 1 || integrityResults[0] !== "ok") { - throw new CollectionIndexCorruptionErrorClass( - `Collection index integrity check failed: ${integrityResults.join(", ")}`, - ); - } - try { this.db!.query( "SELECT id, data_json, body, created_at, updated_at, file_mtime FROM docs LIMIT 0", @@ -439,7 +429,9 @@ class SqliteCollectionIndexClass implements CollectionIndexInterface { "SELECT id, mtime_ms, ctime_ms, size, status FROM collection_files LIMIT 0", ).all(); this.db!.query("SELECT rowid, id, data_json, body FROM docs_fts LIMIT 0").all(); + this.validateIntegrityIfDue(); } catch (error) { + if (error instanceof CollectionIndexCorruptionErrorClass) throw error; throw new CollectionIndexCorruptionErrorClass( `Collection index schema is unusable: ${error instanceof Error ? error.message : String(error)}`, { cause: error }, @@ -447,6 +439,29 @@ class SqliteCollectionIndexClass implements CollectionIndexInterface { } } + private validateIntegrityIfDue(): void { + const checkIntervalMs = 24 * 60 * 60 * 1000; + const checked = this.db!.query( + "SELECT checked_at FROM collection_health WHERE key = 'integrity'", + ).get() as { checked_at: number } | null; + if (checked && Date.now() - checked.checked_at < checkIntervalMs) return; + + const integrityRows = this.db!.query("PRAGMA quick_check;").all() as Array< + Record + >; + const integrityResults = integrityRows.flatMap((row) => Object.values(row)); + if (integrityResults.length !== 1 || integrityResults[0] !== "ok") { + throw new CollectionIndexCorruptionErrorClass( + `Collection index integrity check failed: ${integrityResults.join(", ")}`, + ); + } + this.db!.query( + `INSERT INTO collection_health (key, checked_at) + VALUES ('integrity', $checkedAt) + ON CONFLICT(key) DO UPDATE SET checked_at = excluded.checked_at`, + ).run({ checkedAt: Date.now() }); + } + private isRecoverable(error: unknown): boolean { if (error instanceof CollectionIndexCorruptionErrorClass) return true; if (typeof error !== "object" || error === null || !("code" in error)) return false; @@ -482,6 +497,12 @@ class SqliteCollectionIndexClass implements CollectionIndexInterface { status TEXT NOT NULL CHECK(status IN ('indexed', 'invalid')) ); `); + this.db!.run(` + CREATE TABLE IF NOT EXISTS collection_health ( + key TEXT PRIMARY KEY, + checked_at INTEGER NOT NULL + ); + `); this.db!.run(` CREATE VIRTUAL TABLE IF NOT EXISTS docs_fts USING fts5( id, data_json, body, @@ -986,36 +1007,20 @@ export class ToolCollectionServiceClass { if (!definitions || Object.keys(definitions).length === 0) return undefined; const toolDir = dirname(tool.path); - const handles: Record> = {}; - - const results = await Promise.allSettled( - Object.entries(definitions).map(async ([name, def]) => { + return Object.fromEntries( + Object.entries(definitions).map(([name, def]) => { const collectionName = new CollectionNameClass(name); const collectionPath = join(toolDir, collectionName.value); const handle = this.handleFactory.create(collectionName.value, collectionPath, def ?? {}); - try { - await handle.init(); - } catch (error) { - handle.close(); - throw error; - } - handles[name] = handle; + return [name, new LazyCollectionHandleClass(handle)]; }), ); - - const failure = results.find((result) => result.status === "rejected"); - if (failure?.status === "rejected") { - this.close(handles); - throw failure.reason; - } - - return handles; } close(handles: Record> | undefined): void { if (!handles) return; for (const handle of Object.values(handles)) { - (handle as CollectionHandleImplClass).close(); + (handle as LazyCollectionHandleClass).close(); } } } @@ -1029,6 +1034,93 @@ export interface CollectionHandleFactory { create(name: string, path: string, definition: CollectionDefinition): ManagedCollectionHandle; } +export class LazyCollectionHandleClass> implements CollectionHandle { + public readonly name: string; + public readonly path: string; + private initialization?: Promise; + private initializedHandle?: ManagedCollectionHandle; + + public constructor(private readonly handle: ManagedCollectionHandle) { + this.name = handle.name; + this.path = handle.path; + } + + public async create(entry: { id?: string; data: T; body?: string }): Promise> { + return (await this.resource()).create(entry) as Promise>; + } + + public async getEntry(id: string): Promise | null> { + return (await this.resource()).getEntry(id) as Promise | null>; + } + + public async update( + id: string, + patch: { data?: Partial; body?: string }, + ): Promise> { + return (await this.resource()).update(id, patch) as Promise>; + } + + public async upsert(entry: { + id: string; + data: T; + body?: string; + }): Promise<{ id: string; created: boolean }> { + return (await this.resource()).upsert(entry); + } + + public async remove(id: string): Promise { + return (await this.resource()).remove(id); + } + + public async list(opts?: ListOptions): Promise<{ entries: CollectionEntry[]; total: number }> { + return (await this.resource()).list(opts) as Promise<{ + entries: CollectionEntry[]; + total: number; + }>; + } + + public async search( + query: string, + opts?: { limit?: number }, + ): Promise<{ entries: SearchResult[] }> { + return (await this.resource()).search(query, opts) as Promise<{ entries: SearchResult[] }>; + } + + public async count(where?: Record): Promise { + return (await this.resource()).count(where); + } + + public async getCollection( + filter?: (entry: CollectionEntry) => boolean, + ): Promise[]> { + return (await this.resource()).getCollection(filter) as Promise[]>; + } + + public async clear(): Promise { + return (await this.resource()).clear(); + } + + public close(): void { + this.initializedHandle?.close(); + } + + private resource(): Promise { + this.initialization ??= this.initialize(); + return this.initialization; + } + + private async initialize(): Promise { + try { + await this.handle.init(); + this.initializedHandle = this.handle; + return this.handle; + } catch (error) { + this.handle.close(); + throw error; + } + } +} + export class CollectionHandleFactoryClass implements CollectionHandleFactory { create(name: string, path: string, definition: CollectionDefinition): ManagedCollectionHandle { return new CollectionHandleImplClass(name, path, definition); diff --git a/src/config/filesystem/rig-paths.ts b/src/config/filesystem/rig-paths.ts index ec66c62..5206849 100644 --- a/src/config/filesystem/rig-paths.ts +++ b/src/config/filesystem/rig-paths.ts @@ -75,6 +75,10 @@ export class RigPathsClass { return join(this.rigDir, "update-check.json"); } + get toolMetadataCachePath(): string { + return join(this.rigDir, "tool-metadata.json"); + } + get migrationPromptStatePath(): string { return join(this.rigDir, "migration-prompts.json"); } diff --git a/src/dev/dev-link.test.ts b/src/dev/dev-link.test.ts index 3dcfc6f..4d367e0 100644 --- a/src/dev/dev-link.test.ts +++ b/src/dev/dev-link.test.ts @@ -89,6 +89,6 @@ describe("dev link", () => { expect(linked.pointsToCurrentRepo).toBe(true); expect(shim).toContain("@echo off"); expect(shim).toContain('set "RIG_DEV_REPO='); - expect(shim).toContain('run "%RIG_DEV_REPO%\\src\\cli.ts" %*'); + expect(shim).toContain('run "%RIG_DEV_REPO%\\src\\bin.ts" %*'); }); }); diff --git a/src/dev/dev-link.ts b/src/dev/dev-link.ts index 70202e0..91a0db5 100644 --- a/src/dev/dev-link.ts +++ b/src/dev/dev-link.ts @@ -146,13 +146,13 @@ export class DevLinkServiceClass { return `@echo off rem Rig dev shim. Safe to overwrite with \`rig dev link\`. set "RIG_DEV_REPO=${repoRoot}" -bun --install=fallback run "%RIG_DEV_REPO%\\src\\cli.ts" %* +bun --install=fallback run "%RIG_DEV_REPO%\\src\\bin.ts" %* `; } return `#!/bin/sh # Rig dev shim. Safe to overwrite with \`rig dev link\`. RIG_DEV_REPO=${JSON.stringify(repoRoot)} -exec bun --install=fallback run "$RIG_DEV_REPO/src/cli.ts" "$@" +exec bun --install=fallback run "$RIG_DEV_REPO/src/bin.ts" "$@" `; } diff --git a/src/registry/application/discover-tools.ts b/src/registry/application/discover-tools.ts index 92258c5..ed37226 100644 --- a/src/registry/application/discover-tools.ts +++ b/src/registry/application/discover-tools.ts @@ -1,4 +1,4 @@ -import { existsSync, statSync } from "node:fs"; +import { existsSync, lstatSync, statSync } from "node:fs"; import { readdir } from "node:fs/promises"; import { dirname, join } from "node:path"; import { RigConfigStoreClass, type ConfigOptions, type RegistryEntry } from "../../config/config"; @@ -57,8 +57,21 @@ export class ToolDiscoveryServiceClass { } async find(name: string): Promise { - const tools = await this.discover(); - const tool = tools.find((entry) => entry.name === name); + if (!/^[A-Za-z0-9_-]+$/.test(name)) { + throw new RigErrorClass("TOOL_NOT_FOUND", `Tool not found: ${name}`, { name }); + } + const config = await this.configStore.ensure(); + const entries = this.configStore.registryEntries(config); + const discovered = entries + .map((entry) => this.discoverNamedTool(entry, name)) + .filter((tool): tool is DiscoveredTool => tool !== undefined); + if (discovered.length > 1) { + throw new RigErrorClass("DUPLICATE_TOOL", `Duplicate tool name: ${name}`, { + name, + paths: discovered.map((tool) => tool.toolPath), + }); + } + const tool = discovered[0]; if (!tool) { throw new RigErrorClass("TOOL_NOT_FOUND", `Tool not found: ${name}`, { name }); } @@ -106,6 +119,36 @@ export class ToolDiscoveryServiceClass { } /* v8 ignore stop */ + private discoverNamedTool(entry: RegistryEntry, name: string): DiscoveredTool | undefined { + const toolDir = join(entry.path, name); + try { + if (!lstatSync(toolDir).isDirectory()) return undefined; + } catch { + return undefined; + } + const toolPaths = RigToolEntryFiles.map((file) => join(toolDir, file)).filter((path) => + existsSync(path), + ); + if (toolPaths.length > 1) { + throw new RigErrorClass("TOOL_INVALID", `Tool ${name} has multiple Rig entry files.`, { + toolDir, + found: toolPaths, + expected: RigToolEntryFiles, + }); + } + if (toolPaths.length === 0) { + this.rejectLegacyEntry(name, toolDir); + return undefined; + } + return { + name, + registryKind: entry.kind, + registryPath: entry.path, + toolDir, + toolPath: toolPaths[0]!, + }; + } + private async discoverRegistry(entry: RegistryEntry): Promise { if (!existsSync(entry.path)) return []; const children = await readdir(entry.path, { withFileTypes: true }); diff --git a/src/registry/registry.test.ts b/src/registry/registry.test.ts index b29974b..d2f1545 100644 --- a/src/registry/registry.test.ts +++ b/src/registry/registry.test.ts @@ -1,11 +1,12 @@ import { afterEach, describe, expect, test } from "vite-plus/test"; -import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises"; +import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { RegistryConfigServiceClass } from "./registry"; import { ToolDiscoveryServiceClass } from "./discover"; import { ToolCreatorClass } from "../tools/create"; -import { ToolListServiceClass } from "../tools/list"; +import { CurrentRigToolApiVersion } from "../tools/domain/tool-api"; +import { ToolListServiceClass, ToolMetadataCacheClass } from "../tools/list"; class TestHomeStore { private readonly homes: string[] = []; @@ -62,7 +63,8 @@ describe("registries", () => { await mkdir(toolDir, { recursive: true }); await writeFile(join(toolDir, "index.rig.tsx"), "export default {};\n", "utf8"); - const tools = await new ToolDiscoveryServiceClass({ homeDir: home }).discover(); + const discovery = new ToolDiscoveryServiceClass({ homeDir: home }); + const tools = await discovery.discover(); expect(tools).toMatchObject([ { @@ -70,6 +72,10 @@ describe("registries", () => { toolPath: join(toolDir, "index.rig.tsx"), }, ]); + expect(await discovery.find("view-tool")).toMatchObject({ + name: "view-tool", + toolPath: join(toolDir, "index.rig.tsx"), + }); }); test("rejects legacy tool.ts entry files", async () => { @@ -78,7 +84,11 @@ describe("registries", () => { await mkdir(toolDir, { recursive: true }); await writeFile(join(toolDir, "tool.ts"), "export default {};\n", "utf8"); - await expect(new ToolDiscoveryServiceClass({ homeDir: home }).discover()).rejects.toThrow( + const discovery = new ToolDiscoveryServiceClass({ homeDir: home }); + await expect(discovery.discover()).rejects.toThrow( + "Tool legacy must use index.rig.ts or index.rig.tsx.", + ); + await expect(discovery.find("legacy")).rejects.toThrow( "Tool legacy must use index.rig.ts or index.rig.tsx.", ); }); @@ -220,6 +230,74 @@ describe("registries", () => { expect(rendered).toContain("rig run local-only.example"); }); + test("reuses serialized metadata until a tool entry changes", async () => { + const home = await homes.create(); + const toolDir = join(home, "rig", "tools", "cached"); + const toolPath = join(toolDir, "index.rig.ts"); + await mkdir(toolDir, { recursive: true }); + await writeFile( + toolPath, + `export default (rig) => { + globalThis.__rigMetadataLoads = (globalThis.__rigMetadataLoads ?? 0) + 1; + const load = globalThis.__rigMetadataLoads; + return rig.defineTool({ + name: "cached", + description: "Cached metadata load " + load + ".", + collections: { + notes: { schema: rig.z.object({ title: rig.z.string() }) }, + optional: undefined, + }, + commands: { + read: rig.defineCommand({ + description: "Read cached metadata.", + input: rig.z.object({}), + output: rig.z.number(), + run: () => load, + }), + }, + }); +};\n`, + "utf8", + ); + + const first = await new ToolListServiceClass({ homeDir: home }).list(); + const second = await new ToolListServiceClass({ homeDir: home }).list(); + expect(first.tools[0]?.description).toBe("Cached metadata load 1."); + expect(first.tools[0]?.collections).toEqual([ + { name: "notes", hasSchema: true }, + { name: "optional", hasSchema: false }, + ]); + expect(second.tools[0]?.description).toBe("Cached metadata load 1."); + + await writeFile( + toolPath, + (await readFile(toolPath, "utf8")).replace( + 'description: "Cached metadata load " + load + ".",', + 'description: "Updated metadata load " + load + ".",', + ), + ); + const updated = await new ToolListServiceClass({ homeDir: home }).list(); + expect(updated.tools[0]?.description).toBe("Updated metadata load 2."); + }); + + test("discards incompatible metadata cache documents", async () => { + const incompatible = [ + [], + { version: 2 }, + { version: 1, toolApiVersion: 999, entries: {} }, + { version: 1, toolApiVersion: CurrentRigToolApiVersion, entries: null }, + ]; + const results = await Promise.all( + incompatible.map(async (value) => { + const home = await homes.create(); + await mkdir(join(home, "rig"), { recursive: true }); + await writeFile(join(home, "rig", "tool-metadata.json"), JSON.stringify(value), "utf8"); + return new ToolMetadataCacheClass({ homeDir: home }).load([]); + }), + ); + expect(results).toEqual(incompatible.map(() => [])); + }); + test("renders plain list entries without embedded line breaks", async () => { const rendered = new ToolListServiceClass().renderPlain({ tools: [ @@ -257,8 +335,34 @@ describe("registries", () => { await mkdir(join(custom, "sample"), { recursive: true }); await writeFile(join(custom, "sample", "index.rig.ts"), "export default {};\n", "utf8"); - await expect(new ToolDiscoveryServiceClass({ homeDir: home }).discover()).rejects.toThrow( - "Duplicate tool name: sample", + const discovery = new ToolDiscoveryServiceClass({ homeDir: home }); + await expect(discovery.discover()).rejects.toThrow("Duplicate tool name: sample"); + await expect(discovery.find("sample")).rejects.toThrow("Duplicate tool name: sample"); + await expect(discovery.find("../sample")).rejects.toThrow("Tool not found: ../sample"); + }); + + test("returns no direct match for a file in the registry", async () => { + const home = await homes.create(); + const toolsDir = join(home, "rig", "tools"); + await mkdir(toolsDir, { recursive: true }); + await writeFile(join(toolsDir, "plain-file"), "not a tool\n", "utf8"); + + await expect( + new ToolDiscoveryServiceClass({ homeDir: home }).find("plain-file"), + ).rejects.toThrow("Tool not found: plain-file"); + }); + + test("rejects multiple direct entry files", async () => { + const home = await homes.create(); + const toolDir = join(home, "rig", "tools", "multiple"); + await mkdir(toolDir, { recursive: true }); + await Promise.all([ + writeFile(join(toolDir, "index.rig.ts"), "export default {};\n", "utf8"), + writeFile(join(toolDir, "index.rig.tsx"), "export default {};\n", "utf8"), + ]); + + await expect(new ToolDiscoveryServiceClass({ homeDir: home }).find("multiple")).rejects.toThrow( + "multiple Rig entry files", ); }); }); diff --git a/src/runtime/logger.test.ts b/src/runtime/logger.test.ts index 8c4541f..21a935d 100644 --- a/src/runtime/logger.test.ts +++ b/src/runtime/logger.test.ts @@ -162,6 +162,7 @@ describe("rig logger", () => { }) .app("second") .info("Second factory line."); + await new Promise((resolve) => queueMicrotask(resolve)); const entries = (await readdir(logDir)).toSorted(); expect(entries).not.toContain("rig-old.log"); @@ -206,15 +207,17 @@ describe("rig logger", () => { ); const fallbackHome = await workspaces.create(); - new RigLoggerFactoryClass({ + const fallbackLogger = new RigLoggerFactoryClass({ homeDir: fallbackHome, env: { RIG_LOG_MAX_BYTES: "not-a-number", RIG_LOG_RETENTION_DAYS: "not-a-number", } as NodeJS.ProcessEnv, - }) - .app("fallback") - .info("Fallback configured line."); + }).app("fallback"); + fallbackLogger.info("Fallback configured line."); + fallbackLogger.info("Second buffered line."); + fallbackLogger.info("Third buffered line."); + await new Promise((resolve) => queueMicrotask(resolve)); expect(await readFile(join(fallbackHome, "rig", ".logs", "rig.log"), "utf8")).toContain( "Fallback configured line.", ); diff --git a/src/runtime/logging/logger.ts b/src/runtime/logging/logger.ts index 16f39db..9d9721d 100644 --- a/src/runtime/logging/logger.ts +++ b/src/runtime/logging/logger.ts @@ -172,24 +172,53 @@ class RollingLogFileDestinationClass extends Writable { callback: (error?: Error | null) => void, ): void { try { - const buffer = Buffer.from(chunk); - this.rotateIfNeeded(buffer.byteLength); - appendFileSync(this.activePath(), buffer); - this.activeSize += buffer.byteLength; - callback(); + this.appendBuffers([Buffer.from(chunk)]); + queueMicrotask(callback); } catch (error) { /* v8 ignore next */ callback(error instanceof Error ? error : new Error(String(error))); } } - private rotateIfNeeded(nextBytes: number): void { - const observedSize = this.fileSize(this.activePath()); - this.activeSize = observedSize; - if (observedSize === 0 || observedSize + nextBytes <= this.options.maxFileSizeBytes) { - return; + override _writev( + chunks: Array<{ chunk: Buffer | string; encoding: BufferEncoding }>, + callback: (error?: Error | null) => void, + ): void { + try { + this.appendBuffers(chunks.map((entry) => Buffer.from(entry.chunk))); + queueMicrotask(callback); + } catch (error) { + /* v8 ignore next */ + callback(error instanceof Error ? error : new Error(String(error))); + } + } + + private appendBuffers(buffers: Buffer[]): void { + let pending: Buffer[] = []; + let pendingBytes = 0; + const flush = () => { + if (pendingBytes === 0) return; + appendFileSync( + this.activePath(), + pending.length === 1 ? pending[0]! : Buffer.concat(pending, pendingBytes), + ); + this.activeSize += pendingBytes; + pending = []; + pendingBytes = 0; + }; + + for (const buffer of buffers) { + if (this.activeSize + pendingBytes + buffer.byteLength > this.options.maxFileSizeBytes) { + flush(); + this.rotateIfNeeded(buffer.byteLength); + } + pending.push(buffer); + pendingBytes += buffer.byteLength; } + flush(); + } + private rotateIfNeeded(nextBytes: number): void { this.rotationLock.run(() => { const lockedSize = this.fileSize(this.activePath()); if (lockedSize === 0 || lockedSize + nextBytes <= this.options.maxFileSizeBytes) { diff --git a/src/tools/collection.test.ts b/src/tools/collection.test.ts index 0517a3e..85411ed 100644 --- a/src/tools/collection.test.ts +++ b/src/tools/collection.test.ts @@ -788,6 +788,7 @@ console.log(JSON.stringify({ before, after }));`, class FaultInjectingCollectionHandleClass implements ManagedCollectionHandle { readonly path = "/tmp/test"; + readonly calls: string[] = []; initialized = false; closeRuns = 0; @@ -805,35 +806,44 @@ class FaultInjectingCollectionHandleClass implements ManagedCollectionHandle { this.closeRuns++; } - create(): never { - throw new Error("unused"); + async create(): Promise { + this.calls.push("create"); + return { id: "created" } as never; } - getEntry(): never { - throw new Error("unused"); + async getEntry(): Promise { + this.calls.push("getEntry"); + return null as never; } - update(): never { - throw new Error("unused"); + async update(): Promise { + this.calls.push("update"); + return { id: "updated" } as never; } - upsert(): never { - throw new Error("unused"); + async upsert(): Promise { + this.calls.push("upsert"); + return { id: "upserted", created: true } as never; } - remove(): never { - throw new Error("unused"); + async remove(): Promise { + this.calls.push("remove"); + return true; } - list(): never { - throw new Error("unused"); + async list(): Promise { + this.calls.push("list"); + return { entries: [], total: 0 } as never; } - search(): never { - throw new Error("unused"); + async search(): Promise { + this.calls.push("search"); + return { entries: [] } as never; } - count(): never { - throw new Error("unused"); + async count(): Promise { + this.calls.push("count"); + return 1; } - getCollection(): never { - throw new Error("unused"); + async getCollection(): Promise { + this.calls.push("getCollection"); + return [] as never; } - clear(): never { - throw new Error("unused"); + async clear(): Promise { + this.calls.push("clear"); } } @@ -851,38 +861,58 @@ class FaultInjectingCollectionHandleFactoryClass implements CollectionHandleFact } describe("ToolCollectionServiceClass cleanup", () => { - it("closes the failing handle and initialized siblings after partial setup", async () => { + it("initializes collections on first use and closes failures", async () => { const factory = new FaultInjectingCollectionHandleFactoryClass(); const service = new ToolCollectionServiceClass(factory); + const handles = await service.setup({ + path: "/tmp/tool/index.rig.ts", + definition: { collections: { ready: {}, broken: {}, unused: undefined } }, + } as never); - await expect( - service.setup({ - path: "/tmp/tool/index.rig.ts", - definition: { collections: { ready: {}, broken: {}, alsoReady: {} } }, - } as never), - ).rejects.toThrow("collection initialization failed"); - + expect(factory.handles.every((handle) => !handle.initialized)).toBe(true); + await expect(handles?.broken?.count()).rejects.toThrow("collection initialization failed"); + expect(factory.handles.find((handle) => handle.name === "broken")?.closeRuns).toBe(1); + + const ready = handles!.ready!; + await ready.create({ data: {} }); + await ready.getEntry("created"); + await ready.update("created", { body: "updated" }); + await ready.upsert({ id: "upserted", data: {} }); + await ready.remove("created"); + await ready.list({ limit: 1 }); + await ready.search("query", { limit: 1 }); + expect(await ready.count({ status: "ready" })).toBe(1); + await ready.getCollection(() => true); + await ready.clear(); + + expect(factory.handles.find((handle) => handle.name === "ready")?.calls).toEqual([ + "create", + "getEntry", + "update", + "upsert", + "remove", + "list", + "search", + "count", + "getCollection", + "clear", + ]); + service.close(handles); expect( factory.handles.map((handle) => [handle.name, handle.initialized, handle.closeRuns]), ).toEqual([ ["ready", true, 1], ["broken", false, 1], - ["alsoReady", true, 1], + ["unused", false, 0], ]); }); - it("returns every initialized handle after successful setup", async () => { - const factory = new FaultInjectingCollectionHandleFactoryClass(); - const service = new ToolCollectionServiceClass(factory); - - const handles = await service.setup({ - path: "/tmp/tool/index.rig.ts", - definition: { collections: { ready: {}, optional: undefined } }, - } as never); - - expect(Object.keys(handles ?? {})).toEqual(["ready", "optional"]); - service.close(handles); - expect(factory.handles.every((handle) => handle.closeRuns === 1)).toBe(true); + it("returns undefined for tools without collections", async () => { + const service = new ToolCollectionServiceClass(); + expect( + await service.setup({ path: "/tmp/tool/index.rig.ts", definition: {} } as never), + ).toBeUndefined(); + service.close(undefined); }); }); diff --git a/src/tools/domain/tool-search.ts b/src/tools/domain/tool-search.ts index 646d5d2..6f99c19 100644 --- a/src/tools/domain/tool-search.ts +++ b/src/tools/domain/tool-search.ts @@ -21,6 +21,17 @@ export type ToolSearchRankedDocument = { matches: ToolSearchFieldMatch[]; }; +type CompiledToolSearchField = ToolSearchField & { + normalizedValue: string; + tokens: string[]; +}; + +type CompiledToolSearchDocument = { + id: string; + fields: CompiledToolSearchField[]; + tokens: string[]; +}; + class ToolSearchTextClass { private readonly stopWords = new Set([ "a", @@ -46,16 +57,23 @@ class ToolSearchTextClass { .trim(); } - public tokens(params: { value: string; removeStopWords?: boolean }): string[] { - const tokens = this.normalize(params).split(/\s+/).filter(Boolean); + public tokensFromNormalized(params: { value: string; removeStopWords?: boolean }): string[] { + const tokens = params.value.split(/\s+/).filter(Boolean); if (!params.removeStopWords) return [...new Set(tokens)]; const meaningful = tokens.filter((token) => !this.stopWords.has(token)); return [...new Set(meaningful.length > 0 ? meaningful : tokens)]; } } +type ToolSearchSimilarityParams = { + query: string; + candidate: string; + queryTrigrams: Set; + candidateTrigrams: Set; +}; + class ToolSearchSimilarityClass { - public score(params: { query: string; candidate: string }): number { + public score(params: ToolSearchSimilarityParams): number { if (params.query === params.candidate) return 1; if ( Math.min(params.query.length, params.candidate.length) >= 3 && @@ -67,26 +85,29 @@ class ToolSearchSimilarityClass { const longest = Math.max(params.query.length, params.candidate.length); /* v8 ignore next -- empty normalized queries return before similarity scoring */ if (longest === 0) return 0; - const editSimilarity = 1 - this.distance(params) / longest; + const minimumDistance = Math.abs(params.query.length - params.candidate.length); + const editSimilarity = + 1 - minimumDistance / longest >= 0.58 ? 1 - this.distance(params) / longest : 0; const trigramSimilarity = this.trigramDice(params); const similarity = Math.max(editSimilarity, trigramSimilarity); return similarity >= 0.58 ? similarity * 0.82 : 0; } private distance(params: { query: string; candidate: string }): number { - const rows = params.query.length + 1; const columns = params.candidate.length + 1; - const matrix = Array.from({ length: rows }, () => Array(columns).fill(0)); - for (let row = 0; row < rows; row++) matrix[row]![0] = row; - for (let column = 0; column < columns; column++) matrix[0]![column] = column; + let previousPrevious = new Uint32Array(columns); + let previous = new Uint32Array(columns); + let current = new Uint32Array(columns); + for (let column = 0; column < columns; column++) previous[column] = column; - for (let row = 1; row < rows; row++) { + for (let row = 1; row <= params.query.length; row++) { + current[0] = row; for (let column = 1; column < columns; column++) { const substitution = params.query[row - 1] === params.candidate[column - 1] ? 0 : 1; - matrix[row]![column] = Math.min( - matrix[row - 1]![column]! + 1, - matrix[row]![column - 1]! + 1, - matrix[row - 1]![column - 1]! + substitution, + current[column] = Math.min( + previous[column]! + 1, + current[column - 1]! + 1, + previous[column - 1]! + substitution, ); if ( row > 1 && @@ -94,36 +115,63 @@ class ToolSearchSimilarityClass { params.query[row - 1] === params.candidate[column - 2] && params.query[row - 2] === params.candidate[column - 1] ) { - matrix[row]![column] = Math.min( - matrix[row]![column]!, - matrix[row - 2]![column - 2]! + substitution, + current[column] = Math.min( + current[column]!, + previousPrevious[column - 2]! + substitution, ); } } + const recycled = previousPrevious; + previousPrevious = previous; + previous = current; + current = recycled; } - return matrix[rows - 1]![columns - 1]!; + return previous[columns - 1]!; } - private trigramDice(params: { query: string; candidate: string }): number { - const left = this.trigrams(params.query); - const right = this.trigrams(params.candidate); - if (left.size === 0 || right.size === 0) return 0; + private trigramDice(params: ToolSearchSimilarityParams): number { + if (params.queryTrigrams.size === 0 || params.candidateTrigrams.size === 0) return 0; let intersection = 0; - for (const value of left) if (right.has(value)) intersection++; - return (2 * intersection) / (left.size + right.size); + for (const value of params.queryTrigrams) + if (params.candidateTrigrams.has(value)) intersection++; + return (2 * intersection) / (params.queryTrigrams.size + params.candidateTrigrams.size); + } +} + +class ToolSearchSimilarityMemoClass { + private readonly similarity = new ToolSearchSimilarityClass(); + private readonly scores = new Map(); + private readonly trigramSets = new Map>(); + + public score(params: { query: string; candidate: string }): number { + const key = `${params.query}\0${params.candidate}`; + const cached = this.scores.get(key); + if (cached !== undefined) return cached; + const score = this.similarity.score({ + ...params, + queryTrigrams: this.trigrams(params.query), + candidateTrigrams: this.trigrams(params.candidate), + }); + this.scores.set(key, score); + return score; } private trigrams(value: string): Set { - if (value.length < 3) return new Set(); - return new Set( - Array.from({ length: value.length - 2 }, (_, index) => value.slice(index, index + 3)), - ); + const cached = this.trigramSets.get(value); + if (cached) return cached; + const trigrams = + value.length < 3 + ? new Set() + : new Set( + Array.from({ length: value.length - 2 }, (_, index) => value.slice(index, index + 3)), + ); + this.trigramSets.set(value, trigrams); + return trigrams; } } export class ToolSearchEngineClass { private readonly text = new ToolSearchTextClass(); - private readonly similarity = new ToolSearchSimilarityClass(); public search(params: { query: string; @@ -131,20 +179,48 @@ export class ToolSearchEngineClass { limit: number; }): ToolSearchRankedDocument[] { const normalizedQuery = this.text.normalize({ value: params.query }); - const queryTokens = this.text.tokens({ value: params.query, removeStopWords: true }); + const queryTokens = this.text.tokensFromNormalized({ + value: normalizedQuery, + removeStopWords: true, + }); if (!normalizedQuery || queryTokens.length === 0) return []; + const similarity = new ToolSearchSimilarityMemoClass(); return params.documents - .map((document) => this.rank({ document, normalizedQuery, queryTokens })) + .map((document) => + this.rank({ + document: this.compile(document), + normalizedQuery, + queryTokens, + similarity, + }), + ) .filter((result): result is ToolSearchRankedDocument => result !== undefined) .toSorted((left, right) => right.score - left.score || left.id.localeCompare(right.id)) .slice(0, params.limit); } + private compile(document: ToolSearchDocument): CompiledToolSearchDocument { + const fields = document.fields.map((field) => { + const normalizedValue = this.text.normalize({ value: field.value }); + return { + ...field, + normalizedValue, + tokens: this.text.tokensFromNormalized({ value: normalizedValue }), + }; + }); + return { + id: document.id, + fields, + tokens: [...new Set(fields.flatMap((field) => field.tokens))], + }; + } + private rank(params: { - document: ToolSearchDocument; + document: CompiledToolSearchDocument; normalizedQuery: string; queryTokens: string[]; + similarity: ToolSearchSimilarityMemoClass; }): ToolSearchRankedDocument | undefined { const rawMatches = params.document.fields .map((field) => @@ -152,6 +228,7 @@ export class ToolSearchEngineClass { field, normalizedQuery: params.normalizedQuery, queryTokens: params.queryTokens, + similarity: params.similarity, }), ) .filter((match): match is ToolSearchFieldMatch => match !== undefined) @@ -160,12 +237,9 @@ export class ToolSearchEngineClass { ...new Map(rawMatches.map((match) => [match.field, match] as const)).values(), ].toSorted((left, right) => right.score - left.score); if (matches.length === 0) return undefined; - const documentTokens = params.document.fields.flatMap((field) => - this.text.tokens({ value: field.value }), - ); const coveredTokens = params.queryTokens.filter((queryToken) => - documentTokens.some( - (candidate) => this.similarity.score({ query: queryToken, candidate }) > 0, + params.document.tokens.some( + (candidate) => params.similarity.score({ query: queryToken, candidate }) > 0, ), ).length; const coverage = coveredTokens / params.queryTokens.length; @@ -180,21 +254,22 @@ export class ToolSearchEngineClass { } private matchField(params: { - field: ToolSearchField; + field: CompiledToolSearchField; normalizedQuery: string; queryTokens: string[]; + similarity: ToolSearchSimilarityMemoClass; }): ToolSearchFieldMatch | undefined { - const normalizedField = this.text.normalize({ value: params.field.value }); - if (!normalizedField) return undefined; - const fieldTokens = this.text.tokens({ value: params.field.value }); + if (!params.field.normalizedValue) return undefined; const tokenScores = params.queryTokens.map((queryToken) => Math.max( 0, - ...fieldTokens.map((candidate) => this.similarity.score({ query: queryToken, candidate })), + ...params.field.tokens.map((candidate) => + params.similarity.score({ query: queryToken, candidate }), + ), ), ); const matchedTokens = tokenScores.filter((score) => score > 0); - const phraseBonus = normalizedField.includes(params.normalizedQuery) ? 0.5 : 0; + const phraseBonus = params.field.normalizedValue.includes(params.normalizedQuery) ? 0.5 : 0; if (matchedTokens.length === 0 && phraseBonus === 0) return undefined; const coverage = matchedTokens.length / params.queryTokens.length; const similarity = diff --git a/src/tools/execution/tool-runner.ts b/src/tools/execution/tool-runner.ts index f68c6ed..2be1404 100644 --- a/src/tools/execution/tool-runner.ts +++ b/src/tools/execution/tool-runner.ts @@ -277,7 +277,21 @@ class DryRunPresenterClass { } class ToolExecutionSessionClass { + private readonly commands = new Map< + string, + Awaited> + >(); + constructor(readonly loader: ToolLoaderClass) {} + + async loadCommand(toolName: string, commandName: string) { + const id = commandIds.from(toolName, commandName); + const cached = this.commands.get(id); + if (cached) return cached; + const loaded = await this.loader.loadCommand(toolName, commandName); + this.commands.set(id, loaded); + return loaded; + } } export class ToolRunnerClass { @@ -315,7 +329,7 @@ export class ToolRunnerClass { let collectionHandles: Record> | undefined; const log = this.loggerFactory.tool(toolName, commandName); try { - const { tool, command } = await session.loader.loadCommand(toolName, commandName); + const { tool, command } = await session.loadCommand(toolName, commandName); const input = await this.inputReader.read(command, options); const inputResult = command.input.safeParse(input.value); diff --git a/src/tools/presentation/tool-find.ts b/src/tools/presentation/tool-find.ts index 577e7bf..5a30171 100644 --- a/src/tools/presentation/tool-find.ts +++ b/src/tools/presentation/tool-find.ts @@ -3,10 +3,8 @@ import { RigErrorClass } from "../../errors/RigError"; import { ToolDiscoveryServiceClass } from "../../registry/discover"; import { toolSearchEngine, type ToolSearchDocument } from "../domain/tool-search"; import { ToolNameClass } from "../identifiers"; -import { ToolLoaderClass } from "../loader"; -import { schemaRenderer } from "../schema"; -import { commandIds, type CommandDefinition, type ToolExample } from "../types"; -import { CommandRunExampleRendererClass } from "./tool-list"; +import { commandIds, type ToolExample } from "../types"; +import { ToolMetadataCacheClass, type ToolCommandMetadata } from "./tool-list"; export type ToolFindOptions = { limit?: number | string; @@ -47,13 +45,11 @@ type SearchableCommand = { }; class ToolFindMetadataClass { - private readonly exampleRenderer = new CommandRunExampleRendererClass(); - public command(params: { toolName: string; toolDescription: string; commandName: string; - command: CommandDefinition; + command: ToolCommandMetadata; }): SearchableCommand { const id = commandIds.from(params.toolName, params.commandName); return { @@ -61,7 +57,7 @@ class ToolFindMetadataClass { tool: params.toolName, command: params.commandName, description: params.command.description, - runExample: this.exampleRenderer.render(params.toolName, params.commandName, params.command), + runExample: params.command.runExample, document: { id, fields: [ @@ -70,8 +66,8 @@ class ToolFindMetadataClass { { name: "tool.name", value: params.toolName, weight: 8 }, { name: "command.description", value: params.command.description, weight: 7 }, { name: "tool.description", value: params.toolDescription, weight: 5 }, - ...this.exampleFields(params.command.examples ?? []), - ...this.inputFields(params.command.input), + ...this.exampleFields(params.command.examples), + ...this.inputFields(params.command.inputSchema), ], }, }; @@ -94,8 +90,7 @@ class ToolFindMetadataClass { } private inputFields(schema: unknown): ToolSearchDocument["fields"] { - const jsonSchema = schemaRenderer.toJsonSchema(schema); - return this.walkSchema({ schema: jsonSchema, path: [] }); + return this.walkSchema({ schema, path: [] }); } private walkSchema(params: { schema: unknown; path: string[] }): ToolSearchDocument["fields"] { @@ -167,13 +162,13 @@ class ToolFindPlainRendererClass { export class ToolFindServiceClass { private readonly discovery: ToolDiscoveryServiceClass; - private readonly loader: ToolLoaderClass; + private readonly metadataCache: ToolMetadataCacheClass; private readonly metadata = new ToolFindMetadataClass(); private readonly renderer = new ToolFindPlainRendererClass(); constructor(options: ConfigOptions = {}) { this.discovery = new ToolDiscoveryServiceClass(options); - this.loader = new ToolLoaderClass(options); + this.metadataCache = new ToolMetadataCacheClass(options); } public async find(params: { query: string; options?: ToolFindOptions }): Promise { @@ -189,21 +184,17 @@ export class ToolFindServiceClass { }); } - const searchable = ( - await Promise.all( - selected.map(async (entry) => { - const loaded = await this.loader.loadDiscovered(entry); - return Object.entries(loaded.definition.commands).map(([commandName, command]) => - this.metadata.command({ - toolName: loaded.definition.name, - toolDescription: loaded.definition.description, - commandName, - command, - }), - ); + const loadedMetadata = await this.metadataCache.load(selected, { prune: tool === undefined }); + const searchable = loadedMetadata.flatMap((loaded) => + loaded.commands.map((command) => + this.metadata.command({ + toolName: loaded.name, + toolDescription: loaded.description, + commandName: command.name, + command, }), - ) - ).flat(); + ), + ); const byId = new Map(searchable.map((command) => [command.id, command])); const ranked = toolSearchEngine.search({ query, diff --git a/src/tools/presentation/tool-help.ts b/src/tools/presentation/tool-help.ts index a99602e..9a3b18f 100644 --- a/src/tools/presentation/tool-help.ts +++ b/src/tools/presentation/tool-help.ts @@ -175,7 +175,7 @@ export class ToolHelpServiceClass { async render(toolName: string, commandName?: string): Promise { const target = this.helpTarget(toolName, commandName); - const tool = await this.loader.load(target.toolName); + const tool = await this.loader.loadDefinition(target.toolName); return this.renderer.render(tool.definition, target.commandName); } diff --git a/src/tools/presentation/tool-inspector.ts b/src/tools/presentation/tool-inspector.ts index b28f970..b926107 100644 --- a/src/tools/presentation/tool-inspector.ts +++ b/src/tools/presentation/tool-inspector.ts @@ -14,7 +14,7 @@ export class ToolInspectorClass { async inspect(toolName: string, commandName?: string) { const target = this.inspectTarget(toolName, commandName); - const loaded = await this.loader.load(target.toolName); + const loaded = await this.loader.loadDefinition(target.toolName); const definition = loaded.definition; if (target.commandName) { diff --git a/src/tools/presentation/tool-list.ts b/src/tools/presentation/tool-list.ts index eab9a34..2b59a06 100644 --- a/src/tools/presentation/tool-list.ts +++ b/src/tools/presentation/tool-list.ts @@ -1,9 +1,13 @@ +import { readFile, stat } from "node:fs/promises"; import type { ConfigOptions } from "../../config/config"; +import { AtomicFileWriterClass } from "../../config/file-lock"; +import { RigPathsClass } from "../../config/paths"; +import { ToolDiscoveryServiceClass, type DiscoveredTool } from "../../registry/discover"; import type { CollectionDefinition } from "../collection"; -import { ToolDiscoveryServiceClass } from "../../registry/discover"; +import { CurrentRigToolApiVersion } from "../domain/tool-api"; +import { ToolLoaderClass, type LoadedToolDefinition } from "../loader"; import { schemaRenderer } from "../schema"; -import { ToolLoaderClass } from "../loader"; -import { commandIds, type CommandDefinition } from "../types"; +import { commandIds, type CommandDefinition, type ToolExample } from "../types"; export type ToolListOptions = { visibleFromPath?: string; @@ -106,6 +110,171 @@ export class CommandRunExampleRendererClass { } } +export type ToolCommandMetadata = { + name: string; + description: string; + inputSchema: unknown; + outputSchema: unknown; + examples: ToolExample[]; + runExample: string; +}; + +export type ToolMetadata = { + name: string; + description: string; + commands: ToolCommandMetadata[]; + collections: ListedCollection[]; +}; + +type ToolMetadataCacheEntry = { + modifiedAtMs: number; + changedAtMs: number; + size: number; + metadata: ToolMetadata; +}; + +type ToolMetadataCache = { + version: 1; + toolApiVersion: number; + entries: Record; +}; + +export class ToolMetadataCacheClass { + private readonly paths: RigPathsClass; + private readonly loader: ToolLoaderClass; + private readonly writer = new AtomicFileWriterClass(); + private readonly exampleRenderer = new CommandRunExampleRendererClass(); + + public constructor(options: ConfigOptions = {}) { + this.paths = new RigPathsClass(options); + this.loader = new ToolLoaderClass(options); + } + + public async load( + entries: DiscoveredTool[], + options: { prune?: boolean } = {}, + ): Promise { + const current = await this.read(); + const nextEntries: Record = + options.prune === false ? { ...current.entries } : {}; + let changed = false; + const metadata = await Promise.all( + entries.map(async (entry) => { + const status = await stat(entry.toolPath); + const cached = current.entries[entry.toolPath]; + if ( + cached?.modifiedAtMs === status.mtimeMs && + cached.changedAtMs === status.ctimeMs && + cached.size === status.size && + this.isMetadata(cached.metadata) + ) { + nextEntries[entry.toolPath] = cached; + return cached.metadata; + } + + changed = true; + const loaded = await this.loader.loadDefinitionDiscovered(entry); + const value = this.metadata(loaded); + nextEntries[entry.toolPath] = { + modifiedAtMs: status.mtimeMs, + changedAtMs: status.ctimeMs, + size: status.size, + metadata: value, + }; + return value; + }), + ); + if ( + options.prune !== false && + Object.keys(current.entries).some((path) => nextEntries[path] === undefined) + ) { + changed = true; + } + if (changed) + await this.write({ + version: 1, + toolApiVersion: CurrentRigToolApiVersion, + entries: nextEntries, + }); + return metadata; + } + + private metadata(loaded: LoadedToolDefinition): ToolMetadata { + return { + name: loaded.definition.name, + description: loaded.definition.description, + commands: Object.entries(loaded.definition.commands).map(([name, command]) => ({ + name, + description: command.description, + inputSchema: schemaRenderer.toJsonSchema(command.input), + outputSchema: schemaRenderer.toJsonSchema(command.output), + examples: command.examples ?? [], + runExample: this.exampleRenderer.render(loaded.definition.name, name, command), + })), + collections: this.collections(loaded.definition), + }; + } + + private collections( + definition: Record & { + collections?: Record; + }, + ): ListedCollection[] { + const collections = definition.collections; + if (!collections) return []; + return Object.entries(collections).map(([name, value]) => ({ + name, + hasSchema: Boolean(value?.schema), + })); + } + + private async read(): Promise { + try { + /* v8 ignore next 3 */ + const value = + typeof Bun !== "undefined" + ? await Bun.file(this.paths.toolMetadataCachePath).json() + : JSON.parse(await readFile(this.paths.toolMetadataCachePath, "utf8")); + if (!this.isRecord(value) || value.version !== 1) return this.empty(); + if (value.toolApiVersion !== CurrentRigToolApiVersion || !this.isRecord(value.entries)) { + return this.empty(); + } + return value as ToolMetadataCache; + } catch { + return this.empty(); + } + } + + private async write(cache: ToolMetadataCache): Promise { + try { + await this.writer.write( + this.paths.toolMetadataCachePath, + `${JSON.stringify(cache, null, 2)}\n`, + ); + } catch { + // Metadata caching should never block discovery commands. + } + } + + private empty(): ToolMetadataCache { + return { version: 1, toolApiVersion: CurrentRigToolApiVersion, entries: {} }; + } + + private isMetadata(value: unknown): value is ToolMetadata { + return ( + this.isRecord(value) && + typeof value.name === "string" && + typeof value.description === "string" && + Array.isArray(value.commands) && + Array.isArray(value.collections) + ); + } + + private isRecord(value: unknown): value is Record { + return typeof value === "object" && value !== null && !Array.isArray(value); + } +} + class ToolListPlainTextFormatterClass { description(value: string): string { return value.replace(/\s+/g, " ").trim(); @@ -156,39 +325,35 @@ class ToolListPlainRendererClass { export class ToolListServiceClass { private readonly discovery: ToolDiscoveryServiceClass; - private readonly loader: ToolLoaderClass; - private readonly exampleRenderer = new CommandRunExampleRendererClass(); + private readonly metadataCache: ToolMetadataCacheClass; private readonly plainRenderer = new ToolListPlainRendererClass(); constructor(options: ConfigOptions = {}) { this.discovery = new ToolDiscoveryServiceClass(options); - this.loader = new ToolLoaderClass(options); + this.metadataCache = new ToolMetadataCacheClass(options); } async list(options: ToolListOptions = {}): Promise { const discovered = await this.discovery.discover({ visibleFromPath: options.visibleFromPath }); - const tools = await Promise.all( - discovered.map(async (entry) => { - const loaded = await this.loader.loadDiscovered(entry); - const commands = Object.entries(loaded.definition.commands).map(([name, command]) => ({ - name, - id: commandIds.from(loaded.definition.name, name), + const metadata = await this.metadataCache.load(discovered); + const tools = discovered.map((entry, index) => { + const tool = metadata[index]!; + return { + name: tool.name, + description: tool.description, + registryKind: entry.registryKind, + registryPath: entry.registryPath, + toolPath: entry.toolPath, + commands: tool.commands.map((command) => ({ + name: command.name, + id: commandIds.from(tool.name, command.name), description: command.description, - runExample: this.exampleRenderer.render(loaded.definition.name, name, command), - helpExample: `rig help ${commandIds.from(loaded.definition.name, name)}`, - })); - const collections = this.listCollections(loaded.definition); - return { - name: loaded.definition.name, - description: loaded.definition.description, - registryKind: entry.registryKind, - registryPath: entry.registryPath, - toolPath: entry.toolPath, - commands, - collections, - }; - }), - ); + runExample: command.runExample, + helpExample: `rig help ${commandIds.from(tool.name, command.name)}`, + })), + collections: tool.collections, + }; + }); return { tools, visibleFromPath: options.visibleFromPath }; } @@ -196,19 +361,4 @@ export class ToolListServiceClass { renderPlain(data: ToolListData): string { return this.plainRenderer.render(data); } - - /* v8 ignore start */ - private listCollections( - definition: Record & { - collections?: Record; - }, - ): ListedCollection[] { - const collections = definition.collections; - if (!collections) return []; - return Object.entries(collections).map(([name, def]) => ({ - name, - hasSchema: Boolean(def?.schema), - })); - } - /* v8 ignore stop */ } diff --git a/src/tools/run.test.ts b/src/tools/run.test.ts index 4d6eeab..05e72b9 100644 --- a/src/tools/run.test.ts +++ b/src/tools/run.test.ts @@ -673,6 +673,39 @@ export default (rig) => rig.defineTool({ expect(JSON.stringify(dryRun.envelope)).not.toContain("secret"); }); + test("renders metadata without loading required tool environment values", async () => { + const home = await homes.create(); + const toolDir = join(home, "rig", "tools", "metadata-env"); + await mkdir(toolDir, { recursive: true }); + await writeFile( + join(toolDir, "index.rig.ts"), + `export default (rig) => rig.defineTool({ + name: "metadata-env", + description: "Metadata without env values.", + env: rig.z.object({ API_TOKEN: rig.z.string() }), + commands: { + read: rig.defineCommand({ + description: "Read required env.", + input: rig.z.object({}), + output: rig.z.string(), + run: (context) => context.env.API_TOKEN, + }), + }, +});\n`, + "utf8", + ); + + expect((await new ToolListServiceClass({ homeDir: home }).list()).tools[0]?.name).toBe( + "metadata-env", + ); + expect(await new ToolHelpServiceClass({ homeDir: home }).render("metadata-env")).toContain( + "# metadata-env", + ); + expect(await new ToolInspectorClass({ homeDir: home }).inspect("metadata-env")).toMatchObject({ + name: "metadata-env", + }); + }); + test("returns tool env load errors as envelopes", async () => { const cases = [ { @@ -835,7 +868,7 @@ export default (rig) => rig.defineTool({ expect(FakeSqliteDatabase.store(dbPath)?.closeRuns).toBe(2); }); - test("closes earlier resources when collection setup fails", async () => { + test("skips collection initialization when a command does not use collections", async () => { new FakeSqliteEnvironment().install(); const home = await homes.create(); const toolDir = join(home, "rig", "tools", "partial-setup"); @@ -866,7 +899,8 @@ export default (rig) => rig.defineTool({ homeDir: home, }); - expect(result.exitCode).toBe(1); + expect(result.exitCode).toBe(0); + expect(result.envelope).toMatchObject({ data: { ok: true } }); expect(FakeSqliteDatabase.store(dbPath)?.closeRuns).toBe(1); }); diff --git a/test/e2e/distribution-recovery.e2e.test.ts b/test/e2e/distribution-recovery.e2e.test.ts index 5ae903a..66b1730 100644 --- a/test/e2e/distribution-recovery.e2e.test.ts +++ b/test/e2e/distribution-recovery.e2e.test.ts @@ -237,7 +237,7 @@ describe("installed Rig distribution and recovery", () => { "utf8", ), ) as { bin?: Record }; - expect(installedPackage.bin).toEqual({ rig: "dist/rig.mjs" }); + expect(installedPackage.bin).toEqual({ rig: "dist/bin.mjs" }); const installedFiles = await readdir(installedDistDir); expect(installedFiles).toContain("rig.mjs"); expect(installedFiles.some((file) => file.endsWith(".js"))).toBe(false); diff --git a/test/e2e/harness.ts b/test/e2e/harness.ts index d5763a9..d2c87a8 100644 --- a/test/e2e/harness.ts +++ b/test/e2e/harness.ts @@ -226,7 +226,7 @@ export class RigE2EHarnessFactoryClass { public async create(): Promise { const harnessDir = dirname(fileURLToPath(import.meta.url)); - const cliPath = resolve(this.params.cliPath ?? join(harnessDir, "..", "..", "dist", "rig.mjs")); + const cliPath = resolve(this.params.cliPath ?? join(harnessDir, "..", "..", "dist", "bin.mjs")); if (!existsSync(cliPath)) { throw new Error( `Built Rig CLI is missing at ${cliPath}. Run \`vp run build\` before E2E tests.`, diff --git a/vite.config.ts b/vite.config.ts index 95db8c4..5d8f2de 100644 --- a/vite.config.ts +++ b/vite.config.ts @@ -131,7 +131,7 @@ export default defineConfig({ neverBundle: ["ink", "react", "typescript", /^bun:/], onlyBundle: false, }, - entry: { rig: "src/cli.ts" }, + entry: { bin: "src/bin.ts", rig: "src/cli.ts" }, format: "esm", outDir: "dist", platform: "node",