@rendotdev/rig 0.0.22 → 0.0.23

package/README.md

@@ -62,23 +62,19 @@ Do not implement anything yet. Ask the user which workflow they want to implemen
 
 > Are you an AI agent looking for how to use rig? Assume the following:
 
-The `rig` CLI is installed on this machine. It allows you to write, run and own local tools and scripts in a typed runtime.
-
-- To sync all tools to AGENTS.md and CLAUDE.md, run `rig` (or `rig init`).
-- To discover available tools, run `rig list`.
-- To learn about a tool's usage, run `rig help <tool>`.
-- To run a tool, use `rig run <tool>.<command> [args]`.
-- Tools run under Bun with fallback auto-install enabled, so tool files can import npm packages; add explicit package versions when reproducibility matters.
-- To schedule a tool command, use `rig cron add <name> <tool>.<command> <schedule> --input '<json>'`; use `rig cron list`, `rig cron run <name>`, and `rig cron remove <name>` to manage scheduled runs.
-- If a tool needs local secrets or settings, put them in the tool folder's `.env`, add an `env` Zod schema to the tool definition, and read validated values from `context.env`.
-- To create a new tool, run `rig create <tool>`.
-- To edit an existing tool, run `rig edit <tool>` and open the printed file path.
-- To remove an existing tool, run `rig remove <tool>`.
-- To list tool registries, run `rig registry list`.
-- To add a registry, run `rig registry create [path]` (defaults to current directory).
-- Use `context.log` for structured Pino logs with a default tool command prefix; Rig writes logs to `~/rig/.logs`, rolls files by size, and keeps seven days.
-- Use `context.kv.set(key, value)` and `context.kv.get(key)` for lightweight JSON state in `kv.sqlite` beside the tool entry file.
-- If a tool needs relational persistent state, define `setupDb` and use `context.db`; Rig stores that SQLite database beside the tool entry file as `index.sqlite`.
+The `rig` CLI is installed on this machine. It lets agents discover, run, and create local typed tools.
+
+- Run `rig` (or `rig init`) to set up or sync rig. This also updates detected AGENTS.md and CLAUDE.md files with available rig tools.
+- Run `rig create <tool>` when the user asks you to turn a repeatable workflow into a reusable tool.
+- Run `rig edit <tool>` to print the tool file path for editing.
+- Run `rig remove <tool>` to remove a local tool.
+- Run `rig cron --help` to schedule and manage tool commands.
+- Run `rig typecheck <tool>` to validate a tool's TypeScript and runtime types.
+- Run `rig env <tool> KEY=VALUE` to configure tool secrets/settings; run `rig env <tool> remove KEY` to remove them.
+- Run `rig list` to discover tools and available `rig run ...` commands.
+- Run `rig help <tool>` or `rig help <tool>.<command>` for usage, inputs, and outputs.
+- Run `rig run <tool>.<command> [args]` to execute a tool command.
+- Run `rig --help` for other Rig CLI commands.
 
 When rig runs, it keeps detected `AGENTS.md` and `CLAUDE.md` files updated with these instructions and the current `rig list` output.
 

package/dist/{cli-dqz4gvqd.js → cli-4e71j0m0.js}

@@ -236,7 +236,7 @@ class RigCommandRunnerRuntime {
   }
   async run(options) {
     const target = this.commandTarget(options);
-    const { ToolRunner } = await import("./run-mvhmkkfe.js");
+    const { ToolRunner } = await import("./run-ngbemhx5.js");
     const result = await new ToolRunner(this.options).run(target.tool, target.command, {
       ...this.options,
       args: options.args,
@@ -502,7 +502,10 @@ class ToolLoader {
   validateCommandName(name) {
     this.validator.validateCommandName(name);
   }
-  async loadDiscovered(tool) {
+  async loadDefinition(name) {
+    return this.loadDefinitionDiscovered(await this.discovery.find(name));
+  }
+  async loadDefinitionDiscovered(tool) {
     const url = `${pathToFileURL(tool.toolPath).href}?rig=${Date.now()}`;
     let moduleValue;
     try {
@@ -516,8 +519,12 @@ class ToolLoader {
     const moduleRecord = moduleValue;
     const definitionValue = await this.evaluateModuleDefault(moduleRecord.default, tool.name);
     const definition = this.validator.validateToolDefinition(definitionValue, tool.name);
-    const env = await this.envLoader.load(tool, definition);
-    return { name: definition.name, path: tool.toolPath, env, definition };
+    return { name: definition.name, path: tool.toolPath, definition };
+  }
+  async loadDiscovered(tool) {
+    const loaded = await this.loadDefinitionDiscovered(tool);
+    const env = await this.envLoader.load(tool, loaded.definition);
+    return { ...loaded, env };
   }
   async evaluateModuleDefault(value, toolName) {
     const awaitedValue = await Promise.resolve(value);

package/dist/{cli-1ssn3a04.js → cli-85va7m21.js}

@@ -1,6 +1,6 @@
 import {
   ToolRunner
-} from "./cli-eavzwv49.js";
+} from "./cli-d9b8eefw.js";
 import {
   RigConfigStore
 } from "./cli-043bae8s.js";

package/dist/{cli-eavzwv49.js → cli-d9b8eefw.js}

@@ -5,7 +5,7 @@ import {
   CommandIds,
   ToolLoader,
   createRigToolKit
-} from "./cli-dqz4gvqd.js";
+} from "./cli-4e71j0m0.js";
 import {
   RigError,
   RigErrors

package/dist/{cli-q2ajq5qe.js → cli-exxbjsry.js}

@@ -4,7 +4,7 @@ import {
 import {
   CommandIds,
   ToolLoader
-} from "./cli-dqz4gvqd.js";
+} from "./cli-4e71j0m0.js";
 import {
   ToolDiscoveryService
 } from "./cli-ahwyqf1f.js";
@@ -95,9 +95,9 @@ class ToolListPlainRenderer {
     return `${tool.name} # ${this.formatter.description(tool.description)}`;
   }
   renderCommand(command) {
-    const args = this.formatter.example(command.runExample.replace(`rig run ${command.id}`, ""));
+    const runExample = this.formatter.example(command.runExample);
     const description = this.formatter.description(command.description);
-    return `  ${command.id}${args ? ` ${args}` : ""} # ${description}`;
+    return `  ${runExample} # ${description}`;
   }
 }
 

package/dist/{create-pnsj60ym.js → create-bvzszsyt.js}

@@ -1,6 +1,6 @@
 import {
   ToolLoader
-} from "./cli-dqz4gvqd.js";
+} from "./cli-4e71j0m0.js";
 import {
   RigToolEntryFiles,
   ToolDiscoveryService

package/dist/{cron-zhb9hpbs.js → cron-n15qfj8m.js}

@@ -2,10 +2,10 @@ import {
   RigCronService,
   RigCronWorker,
   cronModuleUrl
-} from "./cli-1ssn3a04.js";
-import"./cli-eavzwv49.js";
+} from "./cli-85va7m21.js";
+import"./cli-d9b8eefw.js";
 import"./cli-zbp3334x.js";
-import"./cli-dqz4gvqd.js";
+import"./cli-4e71j0m0.js";
 import"./cli-ahwyqf1f.js";
 import"./cli-043bae8s.js";
 import"./cli-1c7te5cg.js";

package/dist/env-9kd3dqkx.js

@@ -0,0 +1,190 @@
+import {
+  SchemaRenderer
+} from "./cli-zbp3334x.js";
+import {
+  ToolLoader
+} from "./cli-4e71j0m0.js";
+import"./cli-ahwyqf1f.js";
+import"./cli-043bae8s.js";
+import {
+  RigError
+} from "./cli-1c7te5cg.js";
+import"./cli-32dzwg3p.js";
+import"./cli-b7jgjgy7.js";
+
+// src/tools/env.ts
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+class ToolEnvTarget {
+  tool;
+  constructor(tool) {
+    this.tool = tool;
+  }
+  static parse(value) {
+    if (value && !value.includes("."))
+      return new ToolEnvTarget(value);
+    throw new RigError("INPUT_ERROR", `Env target must use <tool>: ${value}`);
+  }
+}
+
+class EnvKeyParser {
+  parse(keys) {
+    if (keys.length === 0) {
+      throw new RigError("INPUT_ERROR", "Env remove expects at least one KEY.");
+    }
+    return keys.map((key) => this.parseOne(key));
+  }
+  parseOne(key) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+      throw new RigError("INPUT_ERROR", `Env key must be a valid shell variable name: ${key}`);
+    }
+    return key;
+  }
+}
+
+class EnvAssignmentParser {
+  parse(assignments) {
+    return Object.fromEntries(assignments.map((assignment) => this.parseOne(assignment)));
+  }
+  parseOne(assignment) {
+    const separator = assignment.indexOf("=");
+    const key = assignment.slice(0, separator);
+    if (separator <= 0 || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+      throw new RigError("INPUT_ERROR", `Env assignment must use KEY=VALUE: ${assignment}`);
+    }
+    return [key, assignment.slice(separator + 1)];
+  }
+}
+
+class DotEnvDocument {
+  parse(source, path) {
+    const values = {};
+    for (const [index, line] of source.split(/\r?\n/).entries()) {
+      const parsed = this.parseLine(line, path, index + 1);
+      if (parsed)
+        values[parsed.key] = parsed.value;
+    }
+    return values;
+  }
+  serialize(values) {
+    const lines = Object.entries(values).toSorted(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key}=${this.renderValue(value)}`);
+    return `${lines.join(`
+`)}
+`;
+  }
+  parseLine(line, path, lineNumber) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      return;
+    const match = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(trimmed);
+    if (!match) {
+      throw new RigError("TOOL_INVALID", "Invalid .env line.", { path, line: lineNumber });
+    }
+    return { key: match[1], value: this.parseValue(match[2]) };
+  }
+  parseValue(value) {
+    const trimmed = value.trim();
+    if (trimmed.length < 2)
+      return trimmed;
+    if (trimmed[0] === '"' && trimmed.at(-1) === '"')
+      return JSON.parse(trimmed);
+    if (trimmed[0] === "'" && trimmed.at(-1) === "'")
+      return trimmed.slice(1, -1);
+    return trimmed;
+  }
+  renderValue(value) {
+    if (/^[A-Za-z0-9_./:=@%+,-]*$/.test(value))
+      return value;
+    return JSON.stringify(value);
+  }
+}
+
+class EnvSchemaSummary {
+  entries(schema, values) {
+    const jsonSchema = SchemaRenderer.toJsonSchema(schema);
+    if (!this.isRecord(jsonSchema) || !this.isRecord(jsonSchema.properties))
+      return [];
+    const required = Array.isArray(jsonSchema.required) ? jsonSchema.required : [];
+    return Object.keys(jsonSchema.properties).toSorted().map((key) => ({
+      key,
+      required: required.includes(key),
+      set: values[key] !== undefined
+    }));
+  }
+  isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+}
+
+class ToolEnvService {
+  loader;
+  assignments = new EnvAssignmentParser;
+  keys = new EnvKeyParser;
+  document = new DotEnvDocument;
+  summary = new EnvSchemaSummary;
+  constructor(options = {}) {
+    this.loader = new ToolLoader(options);
+  }
+  async configure(targetValue, assignments = []) {
+    const target = ToolEnvTarget.parse(targetValue);
+    const loaded = await this.loader.loadDefinition(target.tool);
+    if (!loaded.definition.env) {
+      throw new RigError("TOOL_INVALID", `Tool ${target.tool} does not define an env schema.`, {
+        tool: target.tool
+      });
+    }
+    const envPath = join(dirname(loaded.path), ".env");
+    const existing = await this.readEnv(envPath);
+    if (assignments.length === 0) {
+      return this.result(target, envPath, false, existing, loaded.definition.env, [], []);
+    }
+    if (assignments[0] === "remove") {
+      const keys = this.keys.parse(assignments.slice(1));
+      const nextValues2 = { ...existing };
+      const removedKeys = keys.filter((key) => (key in nextValues2));
+      for (const key of keys)
+        delete nextValues2[key];
+      this.validateEnv(target, envPath, loaded.definition.env, nextValues2);
+      if (removedKeys.length > 0)
+        await this.writeEnv(envPath, nextValues2);
+      return this.result(target, envPath, removedKeys.length > 0, nextValues2, loaded.definition.env, [], removedKeys);
+    }
+    const updates = this.assignments.parse(assignments);
+    const nextValues = { ...existing, ...updates };
+    this.validateEnv(target, envPath, loaded.definition.env, nextValues);
+    await this.writeEnv(envPath, nextValues);
+    return this.result(target, envPath, true, nextValues, loaded.definition.env, Object.keys(updates), []);
+  }
+  validateEnv(target, envPath, schema, values) {
+    const validation = schema.safeParse(values);
+    if (validation.success)
+      return;
+    throw new RigError("TOOL_INVALID", `Tool ${target.tool} env would be invalid.`, {
+      path: envPath,
+      errors: validation.error?.flatten()
+    });
+  }
+  result(target, envPath, updated, values, schema, updatedKeys, removedKeys) {
+    return {
+      tool: target.tool,
+      envPath,
+      updated,
+      entries: this.summary.entries(schema, values),
+      updatedKeys: updatedKeys.toSorted(),
+      removedKeys: removedKeys.toSorted()
+    };
+  }
+  async readEnv(path) {
+    if (!existsSync(path))
+      return {};
+    return this.document.parse(await readFile(path, "utf8"), path);
+  }
+  async writeEnv(path, values) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, this.document.serialize(values), "utf8");
+  }
+}
+export {
+  ToolEnvService
+};

package/dist/{help-kg1zhj6n.js → help-24c9vwxh.js}

@@ -4,7 +4,7 @@ import {
 import {
   CommandIds,
   ToolLoader
-} from "./cli-dqz4gvqd.js";
+} from "./cli-4e71j0m0.js";
 import"./cli-ahwyqf1f.js";
 import"./cli-043bae8s.js";
 import {

package/dist/{inspect-vqtm5htv.js → inspect-mb0n7sjg.js}

@@ -4,7 +4,7 @@ import {
 import {
   CommandIds,
   ToolLoader
-} from "./cli-dqz4gvqd.js";
+} from "./cli-4e71j0m0.js";
 import"./cli-ahwyqf1f.js";
 import"./cli-043bae8s.js";
 import {

package/dist/{list-2n0p40dn.js → list-jfcspwm7.js}

@@ -1,8 +1,8 @@
 import {
   ToolListService
-} from "./cli-q2ajq5qe.js";
+} from "./cli-exxbjsry.js";
 import"./cli-zbp3334x.js";
-import"./cli-dqz4gvqd.js";
+import"./cli-4e71j0m0.js";
 import"./cli-ahwyqf1f.js";
 import"./cli-043bae8s.js";
 import"./cli-1c7te5cg.js";

package/dist/rig.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   RigCronWorker
-} from "./cli-1ssn3a04.js";
+} from "./cli-85va7m21.js";
 import {
   RigLoggerFactory
-} from "./cli-eavzwv49.js";
+} from "./cli-d9b8eefw.js";
 import"./cli-zbp3334x.js";
-import"./cli-dqz4gvqd.js";
+import"./cli-4e71j0m0.js";
 import"./cli-ahwyqf1f.js";
 import {
   RigPackageRoot
@@ -96,6 +96,7 @@ class CliApplication {
     this.configureCreateCommand();
     this.configureEditCommand();
     this.configureRemoveCommand();
+    this.configureEnvCommand();
     this.configureRunCommand();
     this.configureCronCommands();
     this.configureTypecheckCommand();
@@ -112,7 +113,7 @@ class CliApplication {
         return;
       }
       this.requestGeneratedSync();
-      const { ToolHelpService } = await import("./help-kg1zhj6n.js");
+      const { ToolHelpService } = await import("./help-24c9vwxh.js");
       console.log(await new ToolHelpService(this.pathOptions()).render(target));
     });
   }
@@ -159,7 +160,7 @@ class CliApplication {
   configureListCommand() {
     this.program.command("list").alias("ls").description("List discovered tools and commands.").option("--json", "Print full JSON metadata.").option("--plain", "Print a compact plain text command list.").option("--for-path <path>", "Only list tools from registries visible from a path.").action(async (commandOptions) => {
       this.requestGeneratedSync();
-      const { ToolListService } = await import("./list-2n0p40dn.js");
+      const { ToolListService } = await import("./list-jfcspwm7.js");
       const service = new ToolListService(this.pathOptions());
       const data = await service.list({ visibleFromPath: commandOptions.forPath });
       if (commandOptions.json)
@@ -171,7 +172,7 @@ class CliApplication {
   configureInspectCommand() {
     this.program.command("inspect").argument("<target>", "Tool name or command id (<tool>.<command>.)").description("Print tool or command metadata as JSON.").action(async (target) => {
       this.requestGeneratedSync();
-      const { ToolInspector } = await import("./inspect-vqtm5htv.js");
+      const { ToolInspector } = await import("./inspect-mb0n7sjg.js");
       this.printJson(await new ToolInspector(this.pathOptions()).inspect(target));
     });
   }
@@ -184,7 +185,7 @@ class CliApplication {
   configureEditCommand() {
     this.program.command("edit").argument("<tool>").description("Print the TypeScript file path for a tool.").action(async (name) => {
       this.requestGeneratedSync();
-      const { ToolFileService } = await import("./create-pnsj60ym.js");
+      const { ToolFileService } = await import("./create-bvzszsyt.js");
       const result = await new ToolFileService(this.pathOptions()).path(name);
       console.log(result.toolPath);
     });
@@ -192,12 +193,19 @@ class CliApplication {
   configureRemoveCommand() {
     this.program.command("remove").argument("<tool>").description("Remove a local tool directory.").action(async (name) => {
       this.requestGeneratedSync();
-      const { ToolRemover } = await import("./create-pnsj60ym.js");
+      const { ToolRemover } = await import("./create-bvzszsyt.js");
       const result = await new ToolRemover(this.pathOptions()).remove(name);
       console.log(`Removed tool ${result.name}`);
       console.log(`Tool directory: ${result.toolDir}`);
     });
   }
+  configureEnvCommand() {
+    this.program.command("env").argument("<tool>", "Tool name.").argument("[assignments...]", "Use KEY=VALUE to set values, or remove KEY [KEY...] to remove values.").description("Show, write, or remove tool .env values using its env schema.").action(async (target, assignments) => {
+      this.requestGeneratedSync();
+      const { ToolEnvService } = await import("./env-9kd3dqkx.js");
+      this.printJson(await new ToolEnvService(this.pathOptions()).configure(target, assignments));
+    });
+  }
   configureRunCommand() {
     this.program.command("run").argument("<command>", "Command id, formatted as <tool>.<command>.").argument("[args...]", "Command arguments.").description("Run a tool command.").option("--input <json>", "JSON input string.").option("--input-file <path>", "Read JSON input from a file.").option("--dry-run", "Validate input and show what would run without executing.").action(async (commandId, args, commandOptions) => {
       this.requestGeneratedSync();
@@ -207,11 +215,11 @@ class CliApplication {
   configureCronCommands() {
     const cronCommand = this.program.command("cron").description("Manage scheduled Rig tool commands.");
     cronCommand.command("list").description("List scheduled Rig tool commands as JSON.").action(async () => {
-      const { RigCronService } = await import("./cron-zhb9hpbs.js");
+      const { RigCronService } = await import("./cron-n15qfj8m.js");
       this.printJson(await new RigCronService(this.pathOptions()).list());
     });
     cronCommand.command("add").argument("<name>", "Unique job name, using letters, numbers, hyphens, or underscores.").argument("<command>", "Command id, formatted as <tool>.<command>.").argument("<schedule>", "Cron expression or nickname, such as @weekly.").description("Schedule a Rig tool command with fixed JSON input.").option("--input <json>", "JSON input string.").option("--input-file <path>", "Read JSON input from a file.").action(async (name, commandId, schedule, commandOptions) => {
-      const { cronModuleUrl, RigCronService } = await import("./cron-zhb9hpbs.js");
+      const { cronModuleUrl, RigCronService } = await import("./cron-n15qfj8m.js");
       const result = await new RigCronService(this.pathOptions()).add({
         name,
         command: commandId,
@@ -223,11 +231,11 @@ class CliApplication {
       this.printJson(result);
     });
     cronCommand.command("remove").argument("<name>", "Cron job name.").description("Remove a scheduled Rig tool command.").action(async (name) => {
-      const { RigCronService } = await import("./cron-zhb9hpbs.js");
+      const { RigCronService } = await import("./cron-n15qfj8m.js");
       this.printJson(await new RigCronService(this.pathOptions()).remove(name));
     });
     cronCommand.command("run").argument("<name>", "Cron job name.").description("Run a scheduled Rig tool command now.").action(async (name) => {
-      const { RigCronService } = await import("./cron-zhb9hpbs.js");
+      const { RigCronService } = await import("./cron-n15qfj8m.js");
       const result = await new RigCronService(this.pathOptions()).run(name);
       this.printJson(result.envelope);
       process.exitCode = result.exitCode;
@@ -236,7 +244,7 @@ class CliApplication {
   configureTypecheckCommand() {
     this.program.command("typecheck").argument("[tool]").description("Type-check local tool files with the injected Rig tool runtime types.").action(async (tool) => {
       this.requestGeneratedSync();
-      const { ToolTypecheckService } = await import("./typecheck-c944bvz2.js");
+      const { ToolTypecheckService } = await import("./typecheck-6q579sqn.js");
       const result = await new ToolTypecheckService(this.pathOptions()).typecheck(tool);
       this.printJson(result);
       process.exitCode = result.exitCode;
@@ -289,7 +297,7 @@ class CliApplication {
     });
   }
   async runToolCommand(commandId, args, commandOptions) {
-    const { ToolRunner } = await import("./run-mvhmkkfe.js");
+    const { ToolRunner } = await import("./run-ngbemhx5.js");
     const commandTarget = this.commandTarget(commandId);
     const result = await new ToolRunner(this.pathOptions()).run(commandTarget.tool, commandTarget.command, {
       ...this.pathOptions(),
@@ -332,7 +340,7 @@ Run "rig doctor" if you want to verify your setup.`);
     await this.printUpdateNotice(currentVersion);
   }
   async createTool(name) {
-    const { ToolCreator } = await import("./create-pnsj60ym.js");
+    const { ToolCreator } = await import("./create-bvzszsyt.js");
     const result = await new ToolCreator(this.pathOptions()).create(name);
     console.log(`Created tool ${result.name}`);
     console.log(`
@@ -414,13 +422,13 @@ ${notice.message}`);
   }
   async syncGeneratedFiles() {
     await this.ignoreSyncErrors(async () => {
-      const { ToolRuntimeCommentSyncService } = await import("./runtime-comment-n9aft3g5.js");
+      const { ToolRuntimeCommentSyncService } = await import("./runtime-comment-gbermtjx.js");
       await new ToolRuntimeCommentSyncService(this.pathOptions()).sync();
     });
     if (process.env.RIG_AGENT_SYNC === "0")
       return;
     await this.ignoreSyncErrors(async () => {
-      const { AgentInstructionSyncService } = await import("./sync-javg558s.js");
+      const { AgentInstructionSyncService } = await import("./sync-7x553cky.js");
       await new AgentInstructionSyncService(this.pathOptions()).sync();
     });
   }

package/dist/{run-mvhmkkfe.js → run-ngbemhx5.js}

@@ -1,8 +1,8 @@
 import {
   ToolRunner
-} from "./cli-eavzwv49.js";
+} from "./cli-d9b8eefw.js";
 import"./cli-zbp3334x.js";
-import"./cli-dqz4gvqd.js";
+import"./cli-4e71j0m0.js";
 import"./cli-ahwyqf1f.js";
 import"./cli-043bae8s.js";
 import"./cli-1c7te5cg.js";

package/dist/{runtime-comment-n9aft3g5.js → runtime-comment-gbermtjx.js}

@@ -18,11 +18,14 @@ Rig tool runtime:
 - \`rig.defineTool(definition)\` defines the tool.
 - \`rig.defineCommand(definition)\` defines one command with \`{ description, input, output, run }\`.
 - Use \`rig.z.object({ ... })\` for input/output schemas.
+- Tools run under Bun with fallback auto-install enabled, so tool files can import npm packages; add explicit package versions when reproducibility matters.
 - \`rig.run({ command: "tool.command", input })\` runs another registered Rig command and returns its data.
 - \`rig.$\` runs a Bun Shell tagged template command with escaped interpolations. Docs: https://bun.com/docs/runtime/shell
 - \`rig.args()\` builds argv arrays with \`.raw()\`, \`.flag()\`, \`.value()\`, \`.values()\`, and \`.toArray()\`.
 - \`rig.paths.home()\`, \`rig.paths.resolve(cwd, path)\`, \`rig.paths.ensureParent(path)\`, and \`rig.paths.size(path)\` cover common path work.
-- Add \`env: rig.z.object({ KEY: rig.z.string() })\` to validate a \`.env\` file beside the tool entry file and receive parsed values on \`context.env\`.
+- Add \`env: rig.z.object({ KEY: rig.z.string() })\` to validate local secrets or settings and receive parsed values on \`context.env\`.
+- Run \`rig env <tool> KEY=VALUE\` to write the tool \`.env\` file; run \`rig env <tool> remove KEY\` to remove a value.
+- To add another registry for tool files, run \`rig registry create [path]\` (defaults to current directory).
 
 Tool logging and key-value state:
 - Use \`context.log.info(...)\`, \`context.log.warn(...)\`, or another Pino-style method for structured logs with a default \`tool:<tool>.<command>\` prefix.

package/dist/{sync-javg558s.js → sync-7x553cky.js}

@@ -1,8 +1,8 @@
 import {
   ToolListService
-} from "./cli-q2ajq5qe.js";
+} from "./cli-exxbjsry.js";
 import"./cli-zbp3334x.js";
-import"./cli-dqz4gvqd.js";
+import"./cli-4e71j0m0.js";
 import"./cli-ahwyqf1f.js";
 import"./cli-043bae8s.js";
 import"./cli-1c7te5cg.js";
@@ -17,28 +17,25 @@ import { readFile, realpath, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 
 // src/agents/instructions.ts
-var RigAgentInstructions = `The \`rig\` CLI is installed on this machine. It allows you to write, run and own local tools and scripts in a typed runtime.
+var RigAgentInstructions = `The \`rig\` CLI is installed on this machine. It lets agents discover, run, and create local typed tools.
 
-- To sync all tools to AGENTS.md and CLAUDE.md, run \`rig\` (or \`rig init\`).
-- To discover available tools, run \`rig list\`.
-- To learn about a tool's usage, run \`rig help <tool>\`.
-- To run a tool, use \`rig run <tool>.<command> [args]\`.
-- Tools run under Bun with fallback auto-install enabled, so tool files can import npm packages; add explicit package versions when reproducibility matters.
-- To schedule a tool command, use \`rig cron add <name> <tool>.<command> <schedule> --input '<json>'\`; use \`rig cron list\`, \`rig cron run <name>\`, and \`rig cron remove <name>\` to manage scheduled runs.
-- If a tool needs local secrets or settings, put them in the tool folder's \`.env\`, add an \`env\` Zod schema to the tool definition, and read validated values from \`context.env\`.
-- To create a new tool, run \`rig create <tool>\`.
-- To edit an existing tool, run \`rig edit <tool>\` and open the printed file path.
-- To remove an existing tool, run \`rig remove <tool>\`.
-- To list tool registries, run \`rig registry list\`.
-- To add a registry, run \`rig registry create [path]\` (defaults to current directory).
-- Use \`context.log\` for structured Pino logs with a default tool command prefix; Rig writes logs to \`~/rig/.logs\`, rolls files by size, and keeps seven days.
-- Use \`context.kv.set(key, value)\` and \`context.kv.get(key)\` for lightweight JSON state in \`kv.sqlite\` beside the tool entry file.
-- If a tool needs relational persistent state, define \`setupDb\` and use \`context.db\`; Rig stores that SQLite database beside the tool entry file as \`index.sqlite\`.
+- Run \`rig\` (or \`rig init\`) to set up or sync rig. This also updates detected AGENTS.md and CLAUDE.md files with available rig tools.
+- Run \`rig create <tool>\` when the user asks you to turn a repeatable workflow into a reusable tool.
+- Run \`rig edit <tool>\` to print the tool file path for editing.
+- Run \`rig remove <tool>\` to remove a local tool.
+- Run \`rig cron --help\` to schedule and manage tool commands.
+- Run \`rig typecheck <tool>\` to validate a tool's TypeScript and runtime types.
+- Run \`rig env <tool> KEY=VALUE\` to configure tool secrets/settings; run \`rig env <tool> remove KEY\` to remove them.
+- Run \`rig list\` to discover tools and available \`rig run ...\` commands.
+- Run \`rig help <tool>\` or \`rig help <tool>.<command>\` for usage, inputs, and outputs.
+- Run \`rig run <tool>.<command> [args]\` to execute a tool command.
+- Run \`rig --help\` for other Rig CLI commands.
 `;
 
 // src/agents/sync.ts
 var StartMarker = "<!-- rig:agent-instructions:start -->";
 var EndMarker = "<!-- rig:agent-instructions:end -->";
+var IgnoreMarker = "<!-- rig:ignore -->";
 var AgentInstructionSyncLocations = {
   projectFiles: ["AGENTS.md", "CLAUDE.md"],
   projectClaudeDirectories: [".claude"],
@@ -109,12 +106,15 @@ ${EndMarker}`;
     return this.listService.renderPlain(await this.listService.list(options));
   }
   async addExistingFile(targets, path, scope) {
-    if (await this.isFile(path))
+    if (await this.isFile(path) && !await this.isIgnored(path)) {
       await this.setTarget(targets, path, true, scope);
+    }
   }
   async addClaudeDirectoryTarget(targets, directory, scope) {
     const path = join(directory, "CLAUDE.md");
     const fileExists = await this.isFile(path);
+    if (fileExists && await this.isIgnored(path))
+      return;
     const directoryExists = fileExists ? false : await this.isDirectory(directory);
     if (fileExists || directoryExists)
       await this.setTarget(targets, path, fileExists, scope);
@@ -164,7 +164,7 @@ ${EndMarker}`;
   async setTarget(targets, path, existed, scope) {
     const key = existed ? await this.realPath(path) : path;
     const current = targets.get(key);
-    const nextScope = current?.scope === "visible" || scope === "visible" ? "visible" : "all";
+    const nextScope = current?.scope === "all" || scope === "all" ? "all" : "visible";
     if (!current || path < current.path)
       targets.set(key, { path, existed, scope: nextScope });
     else
@@ -211,6 +211,13 @@ ${EndMarker}`;
   escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   }
+  async isIgnored(path) {
+    try {
+      return (await this.readText(path)).includes(IgnoreMarker);
+    } catch {
+      return false;
+    }
+  }
   async realPath(path) {
     try {
       return await realpath(path);

package/dist/{typecheck-c944bvz2.js → typecheck-6q579sqn.js}

@@ -1,6 +1,6 @@
 import {
   ToolLoader
-} from "./cli-dqz4gvqd.js";
+} from "./cli-4e71j0m0.js";
 import {
   ToolDiscoveryService
 } from "./cli-ahwyqf1f.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rendotdev/rig",
-  "version": "0.0.22",
+  "version": "0.0.23",
   "description": "Local typed command runtime for agents.",
   "homepage": "https://github.com/rendotdev/rig#readme",
   "bugs": {