Add 10 rig samples 331-340 (2026-07-31) (#318)

Author: github-actions[bot]

skills/rig/samples/331-ts-generic-type-extractor.md

@@ -0,0 +1,40 @@
+# 331 - TS Generic Type Extractor
+
+```rig
+import { agent, p, s, defineTool, repair } from "rig";
+import { readFile } from "node:fs/promises";
+
+const extractGenerics = defineTool("extractGenerics", {
+  description: "Extract generic type parameters from a TypeScript file",
+  parameters: s.object({ filePath: s.path }),
+  handler: async ({ filePath }: { filePath: string }) => {
+    const src = await readFile(filePath, "utf-8");
+    const matches = src.match(/<[A-Z][A-Za-z0-9, ]*>/g) ?? [];
+    const generics = [...new Set(matches.map((m: string) => m.slice(1, -1).trim()))];
+    const count = generics.length;
+    const complexity =
+      count === 0 ? "none" as const
+      : count <= 2 ? "simple" as const
+      : count <= 5 ? "moderate" as const
+      : "complex" as const;
+    return { generics, count, complexity };
+  },
+});
+
+// Agent role: find TypeScript files and extract generic type parameters, classifying complexity per file.
+const tsGenericTypeExtractor = agent({
+  model: "small",
+  instructions: p`TypeScript files found: ${p.bash("find . -name '*.ts' -not -path '*/node_modules/*' | head -30")}
+For each file, call extractGenerics to get its generic types and return the results keyed by filename.`,
+  output: s.record(s.object({
+    generics: s.array(s.string),
+    count: s.int,
+    complexity: s.enum("none", "simple", "moderate", "complex"),
+  })),
+  tools: [extractGenerics],
+  addons: [repair()],
+  maxTurns: 6,
+});
+
+export default tsGenericTypeExtractor;
+```

skills/rig/samples/332-shell-script-validator.md

@@ -0,0 +1,43 @@
+# 332 - Shell Script Validator
+
+```rig
+import { agent, p, s, defineTool, steering } from "rig";
+import { readFile } from "node:fs/promises";
+
+const validateScript = defineTool("validateScript", {
+  description: "Validate a shell script for safety best practices",
+  parameters: s.object({ filePath: s.path }),
+  handler: async ({ filePath }: { filePath: string }) => {
+    const src = await readFile(filePath, "utf-8");
+    const hasShebang = src.startsWith("#!");
+    const hasSafeFlags = /set\s+-[euo]*[euo]/.test(src);
+    const hasEval = /\beval\b/.test(src);
+    const functionCount = (src.match(/\bfunction\s+\w+|^\w+\s*\(\s*\)/gm) ?? []).length;
+    let quality: "excellent" | "good" | "fair" | "poor";
+    if (hasShebang && hasSafeFlags && !hasEval) quality = "excellent" as const;
+    else if (hasShebang && hasSafeFlags) quality = "good" as const;
+    else if (hasShebang) quality = "fair" as const;
+    else quality = "poor" as const;
+    return { hasShebang, hasSafeFlags, hasEval, functionCount, quality };
+  },
+});
+
+// Agent role: find shell scripts and validate each for shebang, safe flags, eval usage, and function count.
+const shellScriptValidator = agent({
+  model: "small",
+  instructions: p`Shell scripts found: ${p.bash("find . -name '*.sh' -not -path '*/node_modules/*' | head -30")}
+Call validateScript for each path and return results keyed by file path.`,
+  output: s.record(s.object({
+    hasShebang: s.boolean,
+    hasSafeFlags: s.boolean,
+    hasEval: s.boolean,
+    functionCount: s.int,
+    quality: s.enum("excellent", "good", "fair", "poor"),
+  })),
+  tools: [validateScript],
+  addons: [steering()],
+  maxTurns: 6,
+});
+
+export default shellScriptValidator;
+```

skills/rig/samples/333-ci-flake-triager.md

@@ -0,0 +1,27 @@
+# 333 - CI Flake Triager
+
+```rig
+import { agent, p, s, repair } from "rig";
+
+// Agent role: triage the most recent CI test failure and classify it by root cause.
+const ciFlakeTriager = agent({
+  model: "small",
+  instructions: p`Recent test log:
+${p.bash("cat test-results/last-failure.log 2>/dev/null || echo 'No test log found'")}
+
+Workflow file:
+${p.readOptional(".github/workflows/ci.yml", "(no ci.yml found)")}
+
+Classify the failure. Return failureClass, confidence (0-1), retryAdvice, and affected test names.`,
+  output: s.object({
+    failureClass: s.enum("infrastructure", "assertion", "timeout", "unknown"),
+    confidence: s.number,
+    retryAdvice: s.string,
+    affectedTests: s.array(s.string),
+  }),
+  addons: [repair()],
+  maxTurns: 2,
+});
+
+export default ciFlakeTriager;
+```

skills/rig/samples/334-config-drift-reconciler.md

@@ -0,0 +1,34 @@
+# 334 - Config Drift Reconciler
+
+```rig
+import { agent, p, s } from "rig";
+
+// Agent role: compare baseline and active config, write a corrected patch, and report drifted keys.
+const configDriftReconciler = agent({
+  model: "small",
+  instructions: p`Baseline config:
+${p.readOptional("config/baseline.json", "{}")}
+
+Active config:
+${p.readOptional("config/active.json", "{}")}
+
+Compare the two configs. For each key that differs, record baseline and actual values.
+Produce a patch JSON with corrections and return the analysis.
+${p.writeOutput("patch", "config/patch.json")}`,
+  output: s.object({
+    patch: s.string,
+    changedKeys: s.record(s.object({
+      baseline: s.unknown,
+      actual: s.unknown,
+    })),
+    summary: s.object({
+      totalDrifted: s.int,
+      totalChecked: s.int,
+      normalized: s.boolean,
+    }),
+  }),
+  maxTurns: 4,
+});
+
+export default configDriftReconciler;
+```

skills/rig/samples/335-release-note-enricher.md

@@ -0,0 +1,36 @@
+# 335 - Release Note Enricher
+
+```rig
+import { agent, p, s, defineTool, steering, repair } from "rig";
+
+const lookupTicketMetadata = defineTool("lookupTicketMetadata", {
+  description: "Extract ticket references (#NNN or PROJ-NNN) from text",
+  parameters: s.object({ text: s.string }),
+  handler: ({ text }: { text: string }) => {
+    const githubRefs = text.match(/#\d+/g) ?? [];
+    const projectRefs = text.match(/[A-Z]+-\d+/g) ?? [];
+    return { githubRefs, projectRefs, found: githubRefs.length + projectRefs.length };
+  },
+});
+
+// Agent role: enrich raw release notes by extracting ticket references, categorizing sections, and assessing risk.
+const releaseNoteEnricher = agent({
+  model: "small",
+  input: s.object({ rawNotes: s.string }),
+  instructions: p`Enrich the provided release notes. Call lookupTicketMetadata to extract ticket references.
+Then organize notes into sections (features/bugfixes/breaking/chores), assign a risk label, and list any unresolved references.`,
+  output: s.object({
+    sections: s.array(s.object({
+      title: s.string,
+      items: s.array(s.string),
+    })),
+    riskLabel: s.enum("low", "medium", "high", "critical"),
+    missingReferences: s.array(s.string),
+  }),
+  tools: [lookupTicketMetadata],
+  addons: [steering(), repair()],
+  maxTurns: 6,
+});
+
+export default releaseNoteEnricher;
+```

skills/rig/samples/336-docs-refactor-coordinator.md

@@ -0,0 +1,49 @@
+# 336 - Docs Refactor Coordinator
+
+```rig
+import { agent, p, s } from "rig";
+
+// Agent role: extract API names from README.
+const apiExtractor = agent({
+  name: "apiExtractor",
+  model: "small",
+  instructions: p`Read the README: ${p.read("README.md")}
+Extract all API function and class names mentioned. Return a list of API names.`,
+  output: s.object({
+    apiNames: s.array(s.string),
+  }),
+});
+
+// Agent role: rewrite prose sections of README for clarity.
+const proseCleanup = agent({
+  name: "proseCleanup",
+  model: "small",
+  instructions: p`Read the README: ${p.read("README.md")}
+Rewrite the prose sections for clarity, removing jargon and improving readability. Return cleaned prose.`,
+  output: s.object({
+    cleanedProse: s.string,
+    changesApplied: s.int,
+  }),
+});
+
+// Agent role: coordinate API extraction and prose cleanup, then emit a refactored README.
+const docsRefactorCoordinator = agent({
+  model: "small",
+  instructions: p`Coordinate the documentation refactor:
+1. Ask apiExtractor to extract all API names from README.md
+2. Ask proseCleanup to rewrite the prose
+3. Combine results into a refactoredContent string
+${p.writeOutput("refactoredContent", "refactored.md")}
+Return extractedApis, changesApplied, and outputPath.`,
+  output: s.object({
+    extractedApis: s.array(s.string),
+    changesApplied: s.int,
+    outputPath: s.path,
+    refactoredContent: s.string,
+  }),
+  agents: { apiExtractor, proseCleanup },
+  maxTurns: 6,
+});
+
+export default docsRefactorCoordinator;
+```

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

@@ -0,0 +1,40 @@
+# 337 - Markdown Frontmatter Extractor
+
+```rig
+import { agent, p, s, defineTool, repair } from "rig";
+import { readFile } from "node:fs/promises";
+
+const parseFrontmatter = defineTool("parseFrontmatter", {
+  description: "Parse YAML frontmatter from a markdown file",
+  parameters: s.object({ filePath: s.path }),
+  handler: async ({ filePath }: { filePath: string }) => {
+    const src = await readFile(filePath, "utf-8");
+    const match = src.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) return { hasFrontmatter: false, title: null, date: null, tags: null };
+    const fm = match[1];
+    const title = (fm.match(/^title:\s*(.+)$/m) ?? [])[1]?.trim() ?? null;
+    const date = (fm.match(/^date:\s*(.+)$/m) ?? [])[1]?.trim() ?? null;
+    const tagsMatch = fm.match(/^tags:\s*\[(.+)\]/m);
+    const tags = tagsMatch ? tagsMatch[1].split(",").map((t: string) => t.trim().replace(/['"]/g, "")) : null;
+    return { hasFrontmatter: true, title, date, tags };
+  },
+});
+
+// Agent role: extract YAML frontmatter from all markdown files in the workspace.
+const markdownFrontmatterExtractor = agent({
+  model: "small",
+  instructions: p`Markdown files: ${p.glob("**/*.md")}
+Call parseFrontmatter for each file and return results keyed by file path.`,
+  output: s.record(s.object({
+    hasFrontmatter: s.boolean,
+    title: s.optional(s.string),
+    date: s.optional(s.string),
+    tags: s.optional(s.array(s.string)),
+  })),
+  tools: [parseFrontmatter],
+  addons: [repair()],
+  maxTurns: 8,
+});
+
+export default markdownFrontmatterExtractor;
+```

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

@@ -0,0 +1,52 @@
+# 338 - Git Diff Word Frequency
+
+```rig
+import { agent, p, s, defineTool } from "rig";
+
+const countWordChanges = defineTool("countWordChanges", {
+  description: "Count added and deleted words from a git word-diff porcelain output",
+  parameters: s.object({ diffOutput: s.string }),
+  handler: ({ diffOutput }: { diffOutput: string }) => {
+    const lines = diffOutput.split("\n");
+    const addedWords: Record<string, number> = {};
+    const deletedWords: Record<string, number> = {};
+    for (const line of lines) {
+      if (line.startsWith("+") && !line.startsWith("+++")) {
+        line.slice(1).split(/\s+/).filter(Boolean).forEach((w: string) => {
+          addedWords[w] = (addedWords[w] ?? 0) + 1;
+        });
+      } else if (line.startsWith("-") && !line.startsWith("---")) {
+        line.slice(1).split(/\s+/).filter(Boolean).forEach((w: string) => {
+          deletedWords[w] = (deletedWords[w] ?? 0) + 1;
+        });
+      }
+    }
+    const sortByCount = (m: Record<string, number>) =>
+      Object.entries(m).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([w]) => w);
+    return {
+      topAddedWords: sortByCount(addedWords),
+      topDeletedWords: sortByCount(deletedWords),
+      totalAdditions: Object.values(addedWords).reduce((a, b) => a + b, 0),
+      totalDeletions: Object.values(deletedWords).reduce((a, b) => a + b, 0),
+    };
+  },
+});
+
+// Agent role: analyze word-level changes in the last git diff and report top added/deleted words.
+const gitDiffWordFrequency = agent({
+  model: "small",
+  instructions: p`Word diff output: ${p.bash("git diff --word-diff=porcelain HEAD~1 HEAD 2>/dev/null || git diff --word-diff=porcelain HEAD 2>/dev/null || echo 'no diff'")}
+Call countWordChanges with the diff output and return the word frequency analysis.`,
+  output: s.object({
+    topAddedWords: s.array(s.string),
+    topDeletedWords: s.array(s.string),
+    totalAdditions: s.int,
+    totalDeletions: s.int,
+    mostFrequentAddition: s.optional(s.string),
+  }),
+  tools: [countWordChanges],
+  maxTurns: 4,
+});
+
+export default gitDiffWordFrequency;
+```

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

@@ -0,0 +1,37 @@
+# 339 - TS Async Function Finder
+
+```rig
+import { agent, p, s, defineTool, steering } from "rig";
+import { readFile } from "node:fs/promises";
+
+const scanAsyncFunctions = defineTool("scanAsyncFunctions", {
+  description: "Find async function and method signatures in a TypeScript file",
+  parameters: s.object({ filePath: s.path }),
+  handler: async ({ filePath }: { filePath: string }) => {
+    const src = await readFile(filePath, "utf-8");
+    const matches = src.match(/async\s+(?:function\s+(\w+)|\*?\s*(\w+)\s*\()/g) ?? [];
+    const asyncFunctions = matches.map((m: string) => m.trim());
+    return { asyncFunctions, count: asyncFunctions.length };
+  },
+});
+
+// Agent role: scan TypeScript files for async functions and return per-file counts with totals.
+const tsAsyncFunctionFinder = agent({
+  model: "small",
+  instructions: p`TypeScript files: ${p.bash("find . -name '*.ts' -not -path '*/node_modules/*' | head -40")}
+Call scanAsyncFunctions for each file. Return files record, totalAsync, and mostAsyncFile.`,
+  output: s.object({
+    files: s.record(s.object({
+      asyncFunctions: s.array(s.string),
+      count: s.int,
+    })),
+    totalAsync: s.int,
+    mostAsyncFile: s.optional(s.path),
+  }),
+  tools: [scanAsyncFunctions],
+  addons: [steering()],
+  maxTurns: 8,
+});
+
+export default tsAsyncFunctionFinder;
+```