Add 10 rig samples 130-139 (2026-07-25) (#136)

Samples cover git analysis, LOC stats, import cycles, coverage badges,
license auditing, test mapping, version drift, author stats, path alias
validation, and markdown frontmatter checking.

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: github-actions[bot]

skills/rig/samples/130-git-hotspot-analyzer.md

@@ -0,0 +1,20 @@
+# 130 - Git Hotspot Analyzer
+
+```rig
+import { agent, p, s } from "rig";
+import { steering } from "rig/addons";
+
+// Agent role: analyze which files are hot-spots by measuring commit churn and top contributors.
+const gitHotspotAnalyzer = agent({
+  model: "small",
+  instructions: p`Analyze file churn in this repository. List all tracked files: ${p.bash("git ls-files --exclude-standard | head -100")}. Get commit counts per file: ${p.bash("git log --follow --name-only --format='' -- . | sort | uniq -c | sort -rn | head -40")}. Get top contributors per file via: ${p.bash("git shortlog -sn --no-merges HEAD~50..HEAD 2>/dev/null || git shortlog -sn --no-merges | head -20")}. For each hot-spot file compute a churnScore 0–100 (based on commit frequency relative to max) and list topContributors.`,
+  output: s.record(s.object({
+    churnScore: s.number,
+    topContributors: s.array(s.string),
+  })),
+  maxTurns: 5,
+  addons: [steering({ message: "Every file must have a numeric churnScore between 0 and 100 and at least one topContributor entry." })],
+});
+
+export default gitHotspotAnalyzer;
+```

skills/rig/samples/131-loc-statistics-gatherer.md

@@ -0,0 +1,41 @@
+# 131 - Loc Statistics Gatherer
+
+```rig
+import { agent, p, s, defineTool } from "rig";
+
+const aggregateByExtension = defineTool("aggregateByExtension", {
+  description: "Parse wc -l output and aggregate line and file counts by extension",
+  parameters: s.object({ wcOutput: s.string }),
+  handler: ({ wcOutput }) => {
+    const totals: Record<string, { lineCount: number; fileCount: number }> = {};
+    for (const line of wcOutput.trim().split("\n")) {
+      const match = line.trim().match(/^(\d+)\s+(.+)$/);
+      if (!match) continue;
+      const count = parseInt(match[1], 10);
+      const filePath = match[2];
+      if (filePath === "total") continue;
+      const ext = filePath.includes(".") ? "." + filePath.split(".").pop()! : "(none)";
+      if (!totals[ext]) totals[ext] = { lineCount: 0, fileCount: 0 };
+      totals[ext].lineCount += count;
+      totals[ext].fileCount += 1;
+    }
+    return JSON.stringify(totals);
+  },
+});
+
+// Agent role: gather lines-of-code statistics per file extension and classify overall complexity.
+const locStatisticsGatherer = agent({
+  model: "small",
+  instructions: p`Gather lines-of-code statistics for this repository. List files: ${p.bash("find . -not -path '*/node_modules/*' -not -path '*/.git/*' -type f | head -200")}. Count lines per file: ${p.bash("find . -not -path '*/node_modules/*' -not -path '*/.git/*' -type f -exec wc -l {} + 2>/dev/null | tail -30")}. Use aggregateByExtension to sum lineCount and fileCount per extension. Compute complexityRating: small (<1000 total lines), medium (<5000), large (<20000), xlarge (>=20000).`,
+  output: s.object({
+    byExtension: s.record(s.object({
+      lineCount: s.int,
+      fileCount: s.int,
+    })),
+    complexityRating: s.enum("small", "medium", "large", "xlarge"),
+  }),
+  tools: [aggregateByExtension],
+});
+
+export default locStatisticsGatherer;
+```

skills/rig/samples/132-import-cycle-detector.md

@@ -0,0 +1,31 @@
+# 132 - Import Cycle Detector
+
+```rig
+import { agent, p, s } from "rig";
+import { repair } from "rig/addons";
+
+// Agent role: detect circular import cycles in the TypeScript project and classify severity.
+const importCycleDetector = agent({
+  model: "small",
+  maxTurns: 6,
+  addons: [repair()],
+  instructions: p`Detect circular imports in this TypeScript project.
+
+TypeScript config: ${p.bash("cat tsconfig.json 2>/dev/null || echo '{}'")}
+
+Circular dependency check: ${p.bash("npx --yes madge --circular --extensions ts . 2>/dev/null || echo 'madge unavailable'")}
+
+Import graph sample: ${p.bash("grep -r --include='*.ts' -h 'from ' . 2>/dev/null | grep -v node_modules | head -60")}
+
+Identify all circular import chains. For each cycle, list the path as an array of module names and classify severity: high (core/shared modules), medium (feature modules), low (utility/test files). Set hasCycles to true if any cycles were found.`,
+  output: s.object({
+    hasCycles: s.boolean,
+    cycles: s.array(s.object({
+      path: s.array(s.string),
+      severity: s.enum("high", "medium", "low"),
+    })),
+  }),
+});
+
+export default importCycleDetector;
+```

skills/rig/samples/133-coverage-badge-updater.md

@@ -0,0 +1,26 @@
+# 133 - Coverage Badge Updater
+
+```rig
+import { agent, p, s } from "rig";
+
+// Agent role: read coverage summary and generate shields.io badge markdown, writing it to a coverage report file.
+const coverageBadgeUpdater = agent({
+  model: "small",
+  instructions: p`Read coverage data and generate shields.io badge markdown.
+
+Coverage summary: ${p.readOptional("coverage/coverage-summary.json", "{}")}
+
+Current README: ${p.readOptional("README.md", "")}
+
+Parse the coverage summary JSON. Extract per-category percentages for statements, branches, functions, and lines. Compute overallPct as the average. Set rating: green (>=80%), yellow (60–79%), red (<60%). Generate shields.io badge markdown for each category and the overall percentage. Write the badge markdown to the output field badgeMarkdown. Set badgesWritten to true after generating. ${p.writeOutput("badgeMarkdown", "coverage-badges.md")}`,
+  output: s.object({
+    coverageByCategory: s.record(s.number),
+    overallPct: s.number,
+    rating: s.enum("green", "yellow", "red"),
+    badgesWritten: s.boolean,
+    badgeMarkdown: s.string,
+  }),
+});
+
+export default coverageBadgeUpdater;
+```

skills/rig/samples/134-dep-license-auditor.md

@@ -0,0 +1,41 @@
+# 134 - Dep License Auditor
+
+```rig
+import { agent, p, s, defineTool } from "rig";
+
+const classifyLicense = defineTool("classifyLicense", {
+  description: "Classify a license identifier as permissive, copyleft, or unknown",
+  parameters: s.object({ license: s.string }),
+  handler: ({ license }) => {
+    const l = license.toLowerCase();
+    const permissive = ["mit", "isc", "apache", "bsd", "0bsd", "unlicense", "cc0", "wtfpl", "zlib"];
+    const copyleft = ["gpl", "lgpl", "agpl", "mpl", "eupl", "cddl"];
+    if (permissive.some((p) => l.includes(p))) return "permissive";
+    if (copyleft.some((c) => l.includes(c))) return "copyleft";
+    return "unknown";
+  },
+});
+
+// Agent role: audit npm dependency licenses and flag copyleft or unknown packages.
+const depLicenseAuditor = agent({
+  model: "small",
+  instructions: p`Audit the licenses of all direct npm dependencies.
+
+Direct dependencies: ${p.bash("npm ls --json --depth=0 2>/dev/null | head -300")}
+
+License fields from node_modules: ${p.bash("node -e \"const fs=require('fs'); const d='./node_modules'; if(fs.existsSync(d)) { fs.readdirSync(d).filter(n=>!n.startsWith('.')).slice(0,60).forEach(n=>{ try{const p=JSON.parse(fs.readFileSync(d+'/'+n+'/package.json','utf8')); console.log(n+'|'+(p.license||'NONE'))}catch(e){} }) }\" 2>/dev/null")}
+
+For each direct dependency, use classifyLicense to classify its license. Set hasCopyleft to true if any package has classification copyleft.`,
+  output: s.object({
+    packages: s.array(s.object({
+      name: s.string,
+      license: s.string,
+      classification: s.enum("permissive", "copyleft", "unknown"),
+    })),
+    hasCopyleft: s.boolean,
+  }),
+  tools: [classifyLicense],
+});
+
+export default depLicenseAuditor;
+```

skills/rig/samples/135-test-coverage-mapper.md

@@ -0,0 +1,40 @@
+# 135 - Test Coverage Mapper
+
+```rig
+import { agent, p, s, defineTool } from "rig";
+import { repair } from "rig/addons";
+
+const matchTestFile = defineTool("matchTestFile", {
+  description: "Find matching test files for a source file using filename heuristics",
+  parameters: s.object({ sourceFile: s.string, testFiles: s.array(s.string) }),
+  handler: ({ sourceFile, testFiles }) => {
+    const base = sourceFile.replace(/\.tsx?$/, "").replace(/.*\//, "");
+    const matches = testFiles.filter(
+      (t) => t.includes(base + ".test") || t.includes(base + ".spec")
+    );
+    return JSON.stringify({ matches, partial: matches.length === 0 ? testFiles.filter((t) => t.includes(base)).slice(0, 2) : [] });
+  },
+});
+
+// Agent role: map each TypeScript source file to its test files using filename heuristics.
+const testCoverageMapper = agent({
+  model: "small",
+  maxTurns: 4,
+  addons: [repair()],
+  instructions: p`Map source files to their test counterparts.
+
+Source files: ${p.bash("find . -type f -name '*.ts' -not -name '*.test.ts' -not -name '*.spec.ts' -not -path '*/node_modules/*' | head -50")}
+
+Test files: ${p.bash("find . -type f \\( -name '*.test.ts' -o -name '*.spec.ts' \\) -not -path '*/node_modules/*' | head -50")}
+
+For each source file use matchTestFile to find matches. Classify coverage: covered (matches found), partial (weak match), uncovered (none). Return a record keyed by source file path.`,
+  output: s.record(s.object({
+    coverage: s.enum("covered", "uncovered", "partial"),
+    testFiles: s.array(s.string),
+    reason: s.string,
+  })),
+  tools: [matchTestFile],
+});
+
+export default testCoverageMapper;
+```

skills/rig/samples/136-pkg-version-drift.md

@@ -0,0 +1,31 @@
+# 136 - Pkg Version Drift
+
+```rig
+import { agent, p, s } from "rig";
+
+// Agent role: compare installed npm package versions against latest published versions and report drift.
+const pkgVersionDrift = agent({
+  model: "small",
+  instructions: p`Compare installed npm package versions to the latest published versions.
+
+Package manifest: ${p.read("package.json")}
+
+Installed versions: ${p.bash("npm ls --depth=0 --json 2>/dev/null | head -200")}
+
+Latest versions for key packages: ${p.bash("npm outdated --json 2>/dev/null | head -200 || echo '{}'")}
+
+For each dependency, classify driftLevel: ok (up to date), patch (patch version behind), minor (minor version behind), major (major version behind). Write a human-readable drift summary report via ${p.writeOutput("report", "version-drift-report.md")}. Set reportWritten to true.`,
+  output: s.object({
+    packages: s.array(s.object({
+      name: s.string,
+      current: s.string,
+      latest: s.string,
+      driftLevel: s.enum("ok", "patch", "minor", "major"),
+    })),
+    reportWritten: s.boolean,
+    report: s.string,
+  }),
+});
+
+export default pkgVersionDrift;
+```

skills/rig/samples/137-git-author-stats.md

@@ -0,0 +1,28 @@
+# 137 - Git Author Stats
+
+```rig
+import { agent, p, s } from "rig";
+
+// Agent role: aggregate commit statistics per git author, including first/last commit dates and total counts.
+const gitAuthorStats = agent({
+  model: "small",
+  instructions: p`Aggregate git commit statistics per author.
+
+Commit counts by author: ${p.bash("git shortlog -sne --all 2>/dev/null | head -40")}
+
+Commit log with dates: ${p.bash("git log --format='%ae|%ad' --date=short 2>/dev/null | head -200")}
+
+For each author email, compute commitCount, firstCommit date, and lastCommit date. Identify the topAuthor with the most commits. Compute totalCommits across all authors.`,
+  output: s.object({
+    authors: s.record(s.object({
+      commitCount: s.int,
+      firstCommit: s.string,
+      lastCommit: s.string,
+    })),
+    topAuthor: s.string,
+    totalCommits: s.int,
+  }),
+});
+
+export default gitAuthorStats;
+```

skills/rig/samples/138-ts-path-alias-validator.md

@@ -0,0 +1,41 @@
+# 138 - Ts Path Alias Validator
+
+```rig
+import { agent, p, s, defineTool } from "rig";
+import { existsSync } from "node:fs";
+
+const checkAlias = defineTool("checkAlias", {
+  description: "Check whether a TypeScript path alias target directory exists",
+  parameters: s.object({ alias: s.string, target: s.string }),
+  handler: ({ alias, target }) => {
+    const resolved = target.replace(/\/\*$/, "");
+    const exists = existsSync(resolved);
+    return JSON.stringify({ alias, target, exists });
+  },
+});
+
+// Agent role: validate TypeScript path aliases from tsconfig against actual filesystem paths.
+const tsPathAliasValidator = agent({
+  model: "small",
+  instructions: p`Validate TypeScript path alias configuration.
+
+tsconfig.json: ${p.read("tsconfig.json")}
+
+Files with aliased imports: ${p.bash("find . -name '*.ts' -not -path '*/node_modules/*' | xargs grep -l 'from [\"\\x27]' 2>/dev/null | head -20")}
+
+Import alias usage: ${p.bash("grep -r --include='*.ts' -h 'from [\"\\x27]' . 2>/dev/null | grep -v node_modules | grep -v '\\.' | head -40")}
+
+For each alias in compilerOptions.paths, use checkAlias to verify the target exists. Classify as valid (exists and used), broken (target missing), or unused (exists but no imports found). Report totalAliases and brokenCount.`,
+  output: s.object({
+    aliases: s.record(s.object({
+      target: s.string,
+      status: s.enum("valid", "broken", "unused"),
+    })),
+    totalAliases: s.int,
+    brokenCount: s.int,
+  }),
+  tools: [checkAlias],
+});
+
+export default tsPathAliasValidator;
+```

skills/rig/samples/139-markdown-frontmatter-checker.md

@@ -0,0 +1,45 @@
+# 139 - Markdown Frontmatter Checker
+
+```rig
+import { agent, p, s, defineTool } from "rig";
+import { repair } from "rig/addons";
+import { readFileSync, existsSync } from "node:fs";
+
+const parseFrontmatter = defineTool("parseFrontmatter", {
+  description: "Parse YAML frontmatter from a markdown file and check for required fields",
+  parameters: s.object({ filePath: s.string }),
+  handler: ({ filePath }) => {
+    if (!existsSync(filePath)) return JSON.stringify({ error: "file not found" });
+    const content = readFileSync(filePath, "utf8");
+    if (!content.startsWith("---")) return JSON.stringify({ presentFields: [], missingFields: ["title", "description", "date"], status: "missing" });
+    const end = content.indexOf("---", 3);
+    if (end === -1) return JSON.stringify({ presentFields: [], missingFields: ["title", "description", "date"], status: "missing" });
+    const fm = content.slice(3, end);
+    const required = ["title", "description", "date"];
+    const present = required.filter((f) => new RegExp(`^${f}\\s*:`, "m").test(fm));
+    const missing = required.filter((f) => !present.includes(f));
+    const status = missing.length === 0 ? "complete" : present.length === 0 ? "missing" : "partial";
+    return JSON.stringify({ presentFields: present, missingFields: missing, status });
+  },
+});
+
+// Agent role: check markdown files for required YAML frontmatter fields (title, description, date).
+const markdownFrontmatterChecker = agent({
+  model: "small",
+  maxTurns: 4,
+  addons: [repair()],
+  instructions: p`Check markdown files for required YAML frontmatter fields.
+
+Markdown files: ${p.bash("find . -name '*.md' -not -path '*/node_modules/*' | head -50")}
+
+For each markdown file, use parseFrontmatter to detect which required fields (title, description, date) are present or missing. Return a record keyed by filename.`,
+  output: s.record(s.object({
+    presentFields: s.array(s.string),
+    missingFields: s.array(s.string),
+    status: s.enum("complete", "partial", "missing"),
+  })),
+  tools: [parseFrontmatter],
+});
+
+export default markdownFrontmatterChecker;
+```