Add 10 rig samples 200-209 (2026-07-27) (#211)

Author: github-actions[bot]

skills/rig/samples/200-npm-audit-simplifier.md

@@ -0,0 +1,20 @@
+# 200 - Npm Audit Simplifier
+
+```rig
+import { agent, p, s, repair } from "rig";
+
+// Agent role: run npm audit and produce a simplified grouped vulnerability report with remediation advice.
+const npmAuditSimplifierV2 = agent({
+  model: "small",
+  instructions: p`Run ${p.bash("npm audit --json 2>/dev/null || echo '{}'")} to get the vulnerability report. Parse the JSON output: extract each vulnerability's package name and severity (critical, high, moderate, low, info). Group package names by severity level into the vulnerabilitiesByLevel map. Count all vulnerabilities for totalCount. Write a one-sentence recommendation.`,
+  output: s.object({
+    vulnerabilitiesByLevel: s.record(s.array(s.string)),
+    totalCount: s.number,
+    recommendation: s.string,
+  }),
+  maxTurns: 5,
+  addons: repair(),
+});
+
+export default npmAuditSimplifierV2;
+```

skills/rig/samples/201-git-stash-inventory.md

@@ -0,0 +1,21 @@
+# 201 - Git Stash Inventory
+
+```rig
+import { agent, p, s, repair } from "rig";
+
+// Agent role: inventory all git stashes, listing changed files and estimating staleness.
+const gitStashInventoryV2 = agent({
+  model: "small",
+  instructions: p`List all stashes with timestamps: ${p.bash("git stash list --format='%gd|%ci|%s' 2>/dev/null || echo 'no stashes'")}. For the first three stashes show changed files: ${p.bash("git stash show --name-only stash@{0} 2>/dev/null || true")} ${p.bash("git stash show --name-only stash@{1} 2>/dev/null || true")} ${p.bash("git stash show --name-only stash@{2} 2>/dev/null || true")}. Classify staleness by commit date: fresh (< 1 week), aging (1–4 weeks), stale (1–3 months), ancient (> 3 months).`,
+  output: s.array(s.object({
+    stashRef: s.string,
+    description: s.string,
+    changedFiles: s.array(s.string),
+    staleness: s.enum("fresh", "aging", "stale", "ancient"),
+  })),
+  maxTurns: 5,
+  addons: repair(),
+});
+
+export default gitStashInventoryV2;
+```

skills/rig/samples/202-ts-interface-conflict-checker.md

@@ -0,0 +1,49 @@
+# 202 - Ts Interface Conflict Checker
+
+```rig
+import { agent, p, s, defineTool, repair } from "rig";
+
+const scanInterfaces = defineTool("scanInterfaces", {
+  description: "Scan a TypeScript file for exported interface names using grep",
+  parameters: s.object({ filePath: s.string }),
+  async handler({ filePath }) {
+    const { execSync } = await import("node:child_process");
+    try {
+      const result = execSync(
+        `grep -n "^export interface\\|^interface " "${filePath}" 2>/dev/null || true`,
+        { encoding: "utf8" }
+      );
+      const names = result
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => {
+          const m = line.match(/interface\s+(\w+)/);
+          return m ? m[1] : null;
+        })
+        .filter(Boolean) as string[];
+      return { filePath, names };
+    } catch {
+      return { filePath, names: [] };
+    }
+  },
+});
+
+// Agent role: find duplicate TypeScript interface names across all source files.
+const tsInterfaceConflictCheckerV2 = agent({
+  model: "small",
+  instructions: p`Discover TypeScript source files: ${p.bash("find . -name '*.ts' -not -path '*/node_modules/*' -not -path '*/.git/*' | head -80")}. Use the scanInterfaces tool on each file to collect interface names. Identify interface names declared in more than one file. Classify each conflict as error when names are likely to clash at runtime, warning otherwise. Set hasConflicts to true if any conflicts exist.`,
+  output: s.object({
+    conflicts: s.array(s.object({
+      interfaceName: s.string,
+      files: s.array(s.string),
+      severity: s.enum("warning", "error"),
+    })),
+    hasConflicts: s.boolean,
+  }),
+  tools: [scanInterfaces],
+  maxTurns: 6,
+  addons: repair(),
+});
+
+export default tsInterfaceConflictCheckerV2;
+```

skills/rig/samples/203-git-worktree-mapper.md

@@ -0,0 +1,48 @@
+# 203 - Git Worktree Mapper
+
+```rig
+import { agent, p, s, defineTool } from "rig";
+
+const parseWorktreePorcelain = defineTool("parseWorktreePorcelain", {
+  description: "Parse the porcelain output of git worktree list into structured entries",
+  parameters: s.object({ output: s.string }),
+  handler({ output }) {
+    const entries: Array<{ path: string; branch?: string; state: string }> = [];
+    const blocks = output.trim().split("\n\n");
+    for (const block of blocks) {
+      const lines = block.split("\n");
+      const pathLine = lines.find((l) => l.startsWith("worktree "));
+      const branchLine = lines.find((l) => l.startsWith("branch "));
+      const isLocked = lines.some((l) => l.startsWith("locked"));
+      const isBare = lines.some((l) => l.startsWith("bare"));
+      const entry: { path: string; branch?: string; state: string } = {
+        path: pathLine ? pathLine.replace("worktree ", "") : "",
+        state: isLocked ? "locked" : isBare ? "bare" : "clean",
+      };
+      if (branchLine) entry.branch = branchLine.replace("branch refs/heads/", "");
+      if (entry.path) entries.push(entry);
+    }
+    return entries;
+  },
+});
+
+// Agent role: map all git worktrees and summarize active vs total count.
+const gitWorktreeMapperV2 = agent({
+  model: "small",
+  instructions: p`Get all git worktrees: ${p.bash("git worktree list --porcelain 2>/dev/null || echo ''")}. Use the parseWorktreePorcelain tool to parse the output into structured entries. For each worktree check if there are uncommitted changes (set state to dirty). Count all worktrees for totalCount and non-bare ones for activeCount.`,
+  output: s.object({
+    worktrees: s.array(s.object({
+      path: s.string,
+      branch: s.optional(s.string),
+      state: s.enum("locked", "bare", "clean", "dirty"),
+    })),
+    summary: s.object({
+      totalCount: s.int,
+      activeCount: s.int,
+    }),
+  }),
+  tools: [parseWorktreePorcelain],
+});
+
+export default gitWorktreeMapperV2;
+```

skills/rig/samples/204-test-naming-enforcer.md

@@ -0,0 +1,22 @@
+# 204 - Test Naming Enforcer
+
+```rig
+import { agent, p, s, steering } from "rig";
+
+// Agent role: audit test file naming conventions and report files that violate the standard pattern.
+const testNamingEnforcerV2 = agent({
+  model: "small",
+  instructions: p`Find all test files: ${p.bash("find . \\( -name '*.test.ts' -o -name '*.spec.ts' -o -name '*.test.js' -o -name '*.spec.js' -o -name '*.test.tsx' -o -name '*.spec.tsx' \\) -not -path '*/node_modules/*' | head -80")}. For each file classify the naming convention: correct if the filename follows <subject>.test.<ext> or <subject>.spec.<ext>, wrong-prefix if the prefix before the dot is unusual, wrong-suffix if the extension or suffix is non-standard, missing-spec if the file appears to be a test but lacks a .test. or .spec. marker. Provide suggestedName only when a correction is needed. Set allConform to true only when every file is classified as correct.`,
+  output: s.object({
+    files: s.record(s.object({
+      convention: s.enum("correct", "wrong-prefix", "wrong-suffix", "missing-spec"),
+      suggestedName: s.optional(s.string),
+    })),
+    allConform: s.boolean,
+  }),
+  maxTurns: 5,
+  addons: steering({ message: "Ensure every discovered test file has an entry and allConform reflects all entries." }),
+});
+
+export default testNamingEnforcerV2;
+```

skills/rig/samples/205-pkg-dependency-graph.md

@@ -0,0 +1,40 @@
+# 205 - Pkg Dependency Graph
+
+```rig
+import { agent, p, s, defineTool } from "rig";
+
+const classifyDependency = defineTool("classifyDependency", {
+  description: "Classify a dependency as runtime, dev, or peer based on presence in package.json sections",
+  parameters: s.object({
+    name: s.string,
+    inDependencies: s.boolean,
+    inDevDependencies: s.boolean,
+    inPeerDependencies: s.boolean,
+  }),
+  handler({ inDependencies, inDevDependencies, inPeerDependencies }) {
+    if (inPeerDependencies) return "peer";
+    if (inDevDependencies) return "dev";
+    if (inDependencies) return "runtime";
+    return "dev";
+  },
+});
+
+// Agent role: extract and classify direct dependencies from package.json and describe the dependency tree shape.
+const pkgDependencyGraphV2 = agent({
+  model: "small",
+  instructions: p`Read the project manifest: ${p.read("package.json")}. Get the resolved dependency tree: ${p.bash("npm ls --json --depth=1 2>/dev/null || echo '{}'")}. Use the classifyDependency tool for each direct dependency. List all devDependency names. Classify treeShape as flat (< 5 total deps), shallow (5–20), or deep (> 20). Set depthScore to the total direct dependency count.`,
+  output: s.object({
+    directDeps: s.array(s.object({
+      name: s.string,
+      version: s.string,
+      type: s.enum("runtime", "dev", "peer"),
+    })),
+    devDeps: s.array(s.string),
+    treeShape: s.enum("flat", "shallow", "deep"),
+    depthScore: s.number,
+  }),
+  tools: [classifyDependency],
+});
+
+export default pkgDependencyGraphV2;
+```

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

@@ -0,0 +1,21 @@
+# 206 - Ci Flake Triager
+
+```rig
+import { agent, p, s, repair } from "rig";
+
+// Agent role: triage the most recent CI test failure and classify its root cause.
+const ciFlakeTriager = agent({
+  model: "small",
+  instructions: p`Inspect available CI logs: ${p.bash("cat .github/test-results.log 2>/dev/null || cat test-results.log 2>/dev/null || echo 'no test log found'")}. Also read the CI workflow configuration: ${p.readOptional(".github/workflows/ci.yml", "no ci workflow found")}. Classify the failure type: infrastructure (runner issue, network, timeout on setup), assertion (test logic failed), timeout (test exceeded time limit), or unknown. Estimate confidence. List the names of affected tests if identifiable. Provide a concrete one-sentence retry advice.`,
+  output: s.object({
+    failureClass: s.enum("infrastructure", "assertion", "timeout", "unknown"),
+    confidence: s.enum("high", "medium", "low"),
+    retryAdvice: s.string,
+    affectedTests: s.array(s.string),
+  }),
+  maxTurns: 4,
+  addons: repair(),
+});
+
+export default ciFlakeTriager;
+```

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

@@ -0,0 +1,24 @@
+# 207 - Config Drift Reconciler
+
+```rig
+import { agent, p, s } from "rig";
+
+// Agent role: compare two config files, identify drifted settings, and write a corrected patch.
+const configDriftReconciler = agent({
+  model: "small",
+  instructions: p`Read the baseline ESLint config: ${p.readOptional(".eslintrc.json", "{}")}. Read the active config: ${p.readOptional(".eslintrc.js", "module.exports = {}")}. Also check for any local overrides: ${p.bash("find . -maxdepth 2 -name '.eslintrc*' -not -path '*/node_modules/*' 2>/dev/null || true")}. Identify keys that differ between the baseline and active configs. Write a normalized patch to ${p.write("config-patch.json", "PATCH_CONTENT")} showing the corrected settings. Report each drifted key with its baseline and actual value. Set normalized to true if you were able to resolve all differences.`,
+  output: s.object({
+    changedKeys: s.record(s.object({
+      baseline: s.unknown,
+      actual: s.unknown,
+    })),
+    summary: s.object({
+      totalDrifted: s.int,
+      totalChecked: s.int,
+      normalized: s.boolean,
+    }),
+  }),
+});
+
+export default configDriftReconciler;
+```

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

@@ -0,0 +1,37 @@
+# 208 - Release Note Enricher
+
+```rig
+import { agent, p, s, defineTool, repair, steering } from "rig";
+
+const lookupTicketMetadata = defineTool("lookupTicketMetadata", {
+  description: "Extract ticket references like #123 or PROJ-456 from text",
+  parameters: s.object({ text: s.string }),
+  handler({ text }) {
+    const githubRefs = [...text.matchAll(/#(\d+)/g)].map((m) => `#${m[1]}`);
+    const jiraRefs = [...text.matchAll(/\b([A-Z]+-\d+)\b/g)].map((m) => m[1]);
+    return { githubRefs, jiraRefs, all: [...githubRefs, ...jiraRefs] };
+  },
+});
+
+// Agent role: enrich raw release notes with structured sections, a risk label, and missing reference warnings.
+const releaseNoteEnricher = agent({
+  model: "small",
+  input: s.object({
+    rawNotes: s.string,
+  }),
+  instructions: p`You have raw release notes in the input. Use the lookupTicketMetadata tool to extract any ticket references from the text. Group the notes into logical sections (e.g., Features, Bug Fixes, Breaking Changes, Chores). Assign a riskLabel of low, medium, high, or critical based on whether there are breaking changes or critical fixes. List any ticket references that appear in the notes but could not be resolved or verified.`,
+  output: s.object({
+    sections: s.array(s.object({
+      heading: s.string,
+      items: s.array(s.string),
+    })),
+    riskLabel: s.enum("low", "medium", "high", "critical"),
+    missingReferences: s.array(s.string),
+  }),
+  tools: [lookupTicketMetadata],
+  maxTurns: 5,
+  addons: [steering(), repair()],
+});
+
+export default releaseNoteEnricher;
+```

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

@@ -0,0 +1,35 @@
+# 209 - Docs Refactor Coordinator
+
+```rig
+import { agent, p, s } from "rig";
+
+// Agent role: extract API names mentioned in the documentation.
+const apiExtractor = agent({
+  name: "apiExtractor",
+  model: "nano",
+  instructions: p`Read the documentation: ${p.read("README.md")}. Extract every API name, function signature, and method reference mentioned in the document. Return a flat list of unique API identifiers.`,
+  output: s.array(s.string),
+});
+
+// Agent role: rewrite documentation prose for clarity and conciseness.
+const proseCleanup = agent({
+  name: "proseCleanup",
+  model: "nano",
+  instructions: p`Read the documentation: ${p.read("README.md")}. Rewrite the prose to be clearer, more concise, and better structured. Return only the improved text.`,
+  output: s.string,
+});
+
+// Agent role: coordinate docs refactoring by extracting APIs and cleaning prose, then writing the result.
+const docsRefactorCoordinator = agent({
+  model: "small",
+  instructions: p`Delegate API extraction and prose cleanup to the named subagents. Merge their results: the apiExtractor returns the list of API names, and proseCleanup returns rewritten prose. Combine into a final output and write the refactored content to ${p.write("docs/refactored.md", "REFACTORED_CONTENT")}. Count the changes made to the prose.`,
+  output: s.object({
+    extractedApis: s.array(s.string),
+    changesApplied: s.int,
+    outputPath: s.path,
+  }),
+  agents: { apiExtractor, proseCleanup },
+});
+
+export default docsRefactorCoordinator;
+```