Add 10 rig sample files (401-410) — 2026-08-11 (#404)

Author: github-actions[bot]

skills/rig/samples/401-git-file-at-revision.md

@@ -0,0 +1,40 @@
+# 401 - Git File At Revision
+
+```rig
+import { agent, p, s, repair, defineTool } from "rig";
+
+const extractRevisionMetadata = defineTool("extractRevisionMetadata", {
+  description: "Get commit hash, message, and file content at a given git revision.",
+  parameters: s.object({ revision: s.string, filePath: s.path }),
+  handler: async ({ revision, filePath }: { revision: string; filePath: string }) => {
+    const { execSync } = await import("node:child_process");
+    const fileContent = execSync(`git show ${revision}:${filePath} 2>/dev/null || echo ""`, { encoding: "utf8" });
+    const logLine = execSync(`git log --oneline -1 ${revision} -- ${filePath} 2>/dev/null || echo ""`, { encoding: "utf8" }).trim();
+    const spaceIdx = logLine.indexOf(" ");
+    return {
+      fileContent,
+      commitHash: spaceIdx > -1 ? logLine.slice(0, spaceIdx) : logLine,
+      commitMessage: spaceIdx > -1 ? logLine.slice(spaceIdx + 1) : "",
+      linesCount: fileContent.split("\n").length,
+    };
+  },
+});
+
+// Agent role: Extract file content at a specific git revision and return metadata.
+const gitFileAtRevision = agent({
+  model: "small",
+  input: s.object({ filePath: s.path, revision: s.string }),
+  instructions: p`Use the extractRevisionMetadata tool with the filePath and revision from the input to retrieve the file content and commit metadata. Return all fields exactly as provided by the tool.`,
+  tools: [extractRevisionMetadata],
+  output: s.object({
+    fileContent: s.string,
+    commitHash: s.string,
+    commitMessage: s.string,
+    linesCount: s.int,
+    revision: s.string,
+  }),
+  addons: [repair()],
+});
+
+export default gitFileAtRevision;
+```

skills/rig/samples/402-json-schema-structure-validator.md

@@ -0,0 +1,69 @@
+# 402 - Json Schema Structure Validator
+
+```rig
+import { agent, p, s, repair, defineTool } from "rig";
+
+const validateStructure = defineTool("validateStructure", {
+  description: "Validate a JSON data file against a JSON schema file, checking required fields and types.",
+  parameters: s.object({ schemaContent: s.string, dataContent: s.string }),
+  handler: async ({ schemaContent, dataContent }: { schemaContent: string; dataContent: string }) => {
+    const errors: string[] = [];
+    let schema: Record<string, unknown>;
+    let data: Record<string, unknown>;
+    try {
+      schema = JSON.parse(schemaContent) as Record<string, unknown>;
+    } catch (e) {
+      return { valid: false, errors: ["Invalid JSON in schema file"], checkedFields: 0, schemaTitle: undefined };
+    }
+    try {
+      data = JSON.parse(dataContent) as Record<string, unknown>;
+    } catch (e) {
+      return { valid: false, errors: ["Invalid JSON in data file"], checkedFields: 0, schemaTitle: undefined };
+    }
+    const required = Array.isArray(schema["required"]) ? (schema["required"] as string[]) : [];
+    const properties = (schema["properties"] ?? {}) as Record<string, { type?: string }>;
+    let checkedFields = 0;
+    for (const key of required) {
+      checkedFields++;
+      if (!(key in data)) {
+        errors.push(`Missing required field: ${key}`);
+      } else if (properties[key]?.type) {
+        const expected = properties[key].type as string;
+        const actual = Array.isArray(data[key]) ? "array" : typeof data[key];
+        if (actual !== expected) {
+          errors.push(`Field "${key}" expected type "${expected}" but got "${actual}"`);
+        }
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      checkedFields,
+      schemaTitle: typeof schema["title"] === "string" ? schema["title"] : undefined,
+    };
+  },
+});
+
+// Agent role: Validate a JSON data file against a JSON schema and report structural errors.
+const jsonSchemaStructureValidator = agent({
+  model: "small",
+  input: s.object({ schemaFile: s.path, dataFile: s.path }),
+  instructions: p`Schema file content:
+${p.readInput("schemaFile")}
+
+Data file content:
+${p.readInput("dataFile")}
+
+Use the validateStructure tool with both file contents to check required fields and types. Return the validation result.`,
+  tools: [validateStructure],
+  output: s.object({
+    valid: s.boolean,
+    errors: s.array(s.string),
+    checkedFields: s.int,
+    schemaTitle: s.optional(s.string),
+  }),
+  addons: [repair()],
+});
+
+export default jsonSchemaStructureValidator;
+```

skills/rig/samples/403-markdown-frontmatter-extractor.md

@@ -0,0 +1,53 @@
+# 403 - Markdown Frontmatter Extractor
+
+```rig
+import { agent, p, s, repair, defineTool } from "rig";
+
+const parseFrontmatter = defineTool("parseFrontmatter", {
+  description: "Parse YAML-style frontmatter from a markdown file path.",
+  parameters: s.object({ filePath: s.path }),
+  handler: async ({ filePath }: { filePath: string }) => {
+    const { readFile } = await import("node:fs/promises");
+    const content = await readFile(filePath, "utf8");
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match) {
+      return { hasFrontmatter: false, title: undefined, date: undefined, tags: undefined };
+    }
+    const fm = match[1];
+    const titleMatch = fm.match(/^title:\s*(.+)$/m);
+    const dateMatch = fm.match(/^date:\s*(.+)$/m);
+    const tagsMatch = fm.match(/^tags:\s*\[([^\]]*)\]/m) ?? fm.match(/^tags:\s*\n((?:  - .+\n?)*)/m);
+    let tags: string[] | undefined;
+    if (tagsMatch) {
+      tags = tagsMatch[1].split(/[\n,]/).map((t: string) => t.replace(/^\s*-\s*/, "").trim()).filter(Boolean);
+    }
+    return {
+      hasFrontmatter: true,
+      title: titleMatch ? titleMatch[1].trim() : undefined,
+      date: dateMatch ? dateMatch[1].trim() : undefined,
+      tags,
+    };
+  },
+});
+
+// Agent role: Extract YAML frontmatter metadata from all markdown files in the workspace.
+const markdownFrontmatterExtractor = agent({
+  model: "small",
+  instructions: p`Markdown files found:
+${p.glob("**/*.md")}
+
+For each markdown file path listed above, call the parseFrontmatter tool with that file path. Return a record keyed by file path with the frontmatter fields.`,
+  tools: [parseFrontmatter],
+  output: s.record(
+    s.object({
+      title: s.optional(s.string),
+      date: s.optional(s.string),
+      tags: s.optional(s.array(s.string)),
+      hasFrontmatter: s.boolean,
+    })
+  ),
+  addons: [repair()],
+});
+
+export default markdownFrontmatterExtractor;
+```

skills/rig/samples/404-git-diff-word-frequency.md

@@ -0,0 +1,52 @@
+# 404 - Git Diff Word Frequency
+
+```rig
+import { agent, p, s, defineTool } from "rig";
+
+const countWordChanges = defineTool("countWordChanges", {
+  description: "Count added and deleted words from git --word-diff=porcelain output.",
+  parameters: s.object({ diff: s.string }),
+  handler: ({ diff }: { diff: string }) => {
+    const addedWords: Record<string, number> = {};
+    const deletedWords: Record<string, number> = {};
+    for (const line of diff.split("\n")) {
+      if (line.startsWith("+") && !line.startsWith("+++")) {
+        const word = line.slice(1).trim();
+        if (word) addedWords[word] = (addedWords[word] ?? 0) + 1;
+      } else if (line.startsWith("-") && !line.startsWith("---")) {
+        const word = line.slice(1).trim();
+        if (word) deletedWords[word] = (deletedWords[word] ?? 0) + 1;
+      }
+    }
+    const topAdded = Object.entries(addedWords).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([w]) => w);
+    const topDeleted = Object.entries(deletedWords).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([w]) => w);
+    const mostFrequent = topAdded[0];
+    return {
+      topAddedWords: topAdded,
+      topDeletedWords: topDeleted,
+      totalAdditions: Object.values(addedWords).reduce((a, b) => a + b, 0),
+      totalDeletions: Object.values(deletedWords).reduce((a, b) => a + b, 0),
+      mostFrequentAddition: mostFrequent ?? null,
+    };
+  },
+});
+
+// Agent role: Count added and deleted words in the current git diff and return the top words.
+const gitDiffWordFrequency = agent({
+  model: "small",
+  instructions: p`Word-diff output:
+${p.bash("git diff --word-diff=porcelain")}
+
+Use the countWordChanges tool with the diff content above to count added and deleted words. Return the results.`,
+  tools: [countWordChanges],
+  output: s.object({
+    topAddedWords: s.array(s.string),
+    topDeletedWords: s.array(s.string),
+    totalAdditions: s.int,
+    totalDeletions: s.int,
+    mostFrequentAddition: s.optional(s.string),
+  }),
+});
+
+export default gitDiffWordFrequency;
+```

skills/rig/samples/405-ts-async-function-finder.md

@@ -0,0 +1,41 @@
+# 405 - Ts Async Function Finder
+
+```rig
+import { agent, p, s, steering, defineTool } from "rig";
+
+const scanAsyncFunctions = defineTool("scanAsyncFunctions", {
+  description: "Scan a TypeScript file for async function signatures.",
+  parameters: s.object({ filePath: s.path }),
+  handler: async ({ filePath }: { filePath: string }) => {
+    const { readFile } = await import("node:fs/promises");
+    const content = await readFile(filePath, "utf8");
+    const matches: string[] = [];
+    const asyncFnRe = /async\s+function\s+(\w+)|const\s+(\w+)\s*=\s*async\s*(?:\([^)]*\)|[^=]+)\s*=>/g;
+    let m: RegExpExecArray | null;
+    while ((m = asyncFnRe.exec(content)) !== null) {
+      const name = m[1] ?? m[2];
+      if (name) matches.push(name);
+    }
+    return { functions: matches };
+  },
+});
+
+// Agent role: Find all async function signatures in TypeScript source files.
+const tsAsyncFunctionFinder = agent({
+  model: "small",
+  instructions: p`TypeScript files in this repository:
+${p.bash("find . -name '*.ts' -not -path '*/node_modules/*'")}
+
+For each file path listed above, call the scanAsyncFunctions tool. Accumulate results into a record keyed by file path with the list of async function names. Return totalAsync (sum of all async functions) and mostAsyncFile (the file with the most async functions).`,
+  tools: [scanAsyncFunctions],
+  maxTurns: 5,
+  output: s.object({
+    files: s.record(s.array(s.string)),
+    totalAsync: s.int,
+    mostAsyncFile: s.optional(s.path),
+  }),
+  addons: [steering()],
+});
+
+export default tsAsyncFunctionFinder;
+```

skills/rig/samples/406-npm-dep-depth-analyzer.md

@@ -0,0 +1,62 @@
+# 406 - Npm Dep Depth Analyzer
+
+```rig
+import { agent, p, s, repair, defineTool } from "rig";
+
+const classifyDepDepth = defineTool("classifyDepDepth", {
+  description: "Parse npm ls JSON output and classify each dependency by depth.",
+  parameters: s.object({ npmLsJson: s.string }),
+  handler: ({ npmLsJson }: { npmLsJson: string }) => {
+    type DepEntry = { version?: string; dependencies?: Record<string, DepEntry> };
+    const packages: Record<string, { depth: number; depthClass: "direct" | "transitive-shallow" | "transitive-deep" }> = {};
+    let maxDepth = 0;
+    let directCount = 0;
+    function walk(node: DepEntry, depth: number): void {
+      if (!node.dependencies) return;
+      for (const [name, child] of Object.entries(node.dependencies)) {
+        if (depth > maxDepth) maxDepth = depth;
+        const depthClass: "direct" | "transitive-shallow" | "transitive-deep" =
+          depth === 1 ? "direct" : depth === 2 ? "transitive-shallow" : "transitive-deep";
+        if (!packages[name]) {
+          packages[name] = { depth, depthClass };
+          if (depth === 1) directCount++;
+        }
+        walk(child, depth + 1);
+      }
+    }
+    try {
+      const tree = JSON.parse(npmLsJson) as DepEntry;
+      walk(tree, 1);
+    } catch {
+      // empty tree
+    }
+    return { packages, maxDepth, directCount };
+  },
+});
+
+// Agent role: Analyze npm dependency depth by reading package.json and running npm ls.
+const npmDepDepthAnalyzer = agent({
+  model: "small",
+  instructions: p`package.json:
+${p.read("package.json")}
+
+npm dependency tree (JSON):
+${p.bash("npm ls --depth=3 --json 2>/dev/null || echo '{}'")}
+
+Use the classifyDepDepth tool with the npm ls JSON output above. Return packages, maxDepth, and directCount.`,
+  tools: [classifyDepDepth],
+  output: s.object({
+    packages: s.record(
+      s.object({
+        depth: s.int,
+        depthClass: s.enum("direct", "transitive-shallow", "transitive-deep"),
+      })
+    ),
+    maxDepth: s.int,
+    directCount: s.int,
+  }),
+  addons: [repair()],
+});
+
+export default npmDepDepthAnalyzer;
+```

skills/rig/samples/407-http-access-log-stats.md

@@ -0,0 +1,41 @@
+# 407 - Http Access Log Stats
+
+```rig
+import { agent, p, s, repair, defineTool } from "rig";
+
+const parseLogLine = defineTool("parseLogLine", {
+  description: "Parse a single combined log format HTTP access log line and classify the status code.",
+  parameters: s.object({ line: s.string }),
+  handler: ({ line }: { line: string }) => {
+    const m = line.match(/^(\S+)\s+\S+\s+\S+\s+\[([^\]]+)\]\s+"(\w+)\s+(\S+)\s+\S+"\s+(\d+)/);
+    if (!m) return { path: "", statusCode: 0, statusClass: "other" as const };
+    const statusCode = parseInt(m[5], 10);
+    const statusClass =
+      statusCode >= 200 && statusCode < 300 ? "2xx" as const :
+      statusCode >= 300 && statusCode < 400 ? "3xx" as const :
+      statusCode >= 400 && statusCode < 500 ? "4xx" as const :
+      statusCode >= 500 ? "5xx" as const : "other" as const;
+    return { path: m[4], statusCode, statusClass };
+  },
+});
+
+// Agent role: Parse an HTTP access log file and return status count statistics.
+const httpAccessLogStats = agent({
+  model: "small",
+  input: s.object({ logFile: s.path }),
+  instructions: p`Access log contents:
+${p.readInput("logFile")}
+
+For each line in the log, use the parseLogLine tool to extract the path and status class. Aggregate into statusCounts (record of status class to count), topPaths (up to 10 most frequent paths), totalRequests, and errorRate (fraction of 4xx+5xx requests as a number between 0 and 1).`,
+  tools: [parseLogLine],
+  output: s.object({
+    statusCounts: s.record(s.int),
+    topPaths: s.array(s.string),
+    totalRequests: s.int,
+    errorRate: s.number,
+  }),
+  addons: [repair()],
+});
+
+export default httpAccessLogStats;
+```