Add 10 rig samples (140-149): hotspot, loc-stats, cycle-detect, badges, licenses, coverage, permissions, submodules, decorators, dotfiles

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: github-actions[bot]

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

@@ -0,0 +1,41 @@
+# 140 - Git Hotspot Analyzer
+
+```rig
+import { agent, p, s, defineTool } from "rig";
+import { steering } from "rig/addons";
+
+const scoreFile = defineTool("scoreFile", {
+  description: "Compute a churn score from commit count for a file.",
+  parameters: s.object({ filename: s.string, commitCount: s.int }),
+  handler({ commitCount }) {
+    const score = Math.log1p(commitCount) * 10;
+    return { churnScore: Math.round(score * 100) / 100 };
+  },
+});
+
+// Agent role: Analyze git history to identify hot-spot files by churn frequency.
+const gitHotspotAnalyzer = agent({
+  model: "small",
+  instructions: p`Analyze the git log to find frequently-changed files.
+
+Use the git history:
+${p.bash("git log --name-only --format= | sort | uniq -c | sort -rn | head -30")}
+
+For each file in the top results, get contributor info:
+${p.bash("git shortlog -sn --no-merges -- . | head -10")}
+
+Use the scoreFile tool to compute a churnScore for each file.
+Return s.record output keyed by file path with churnScore, commitCount, and topContributors.`,
+  tools: [scoreFile],
+  addons: steering({ message: "Ensure all top files appear in the output keyed by their path." }),
+  output: s.record(
+    s.object({
+      churnScore: s.number,
+      commitCount: s.int,
+      topContributors: s.array(s.string),
+    }),
+  ),
+});
+
+export default gitHotspotAnalyzer;
+```

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

@@ -0,0 +1,49 @@
+# 141 - LOC Statistics Gatherer
+
+```rig
+import { agent, p, s, defineTool } from "rig";
+
+const aggregateByExtension = defineTool("aggregateByExtension", {
+  description: "Aggregate line counts and file counts by extension from wc -l output.",
+  parameters: s.object({ wcOutput: s.string }),
+  handler({ wcOutput }) {
+    const lines = wcOutput.trim().split("\n");
+    const result: Record<string, { lineCount: number; fileCount: number }> = {};
+    for (const line of lines) {
+      const match = line.trim().match(/^(\d+)\s+(.+)$/);
+      if (!match) continue;
+      const count = parseInt(match[1], 10);
+      const file = match[2];
+      const ext = file.includes(".") ? "." + file.split(".").pop()! : "(no-ext)";
+      if (!result[ext]) result[ext] = { lineCount: 0, fileCount: 0 };
+      result[ext].lineCount += count;
+      result[ext].fileCount += 1;
+    }
+    return result;
+  },
+});
+
+// Agent role: Gather lines-of-code statistics grouped by file extension.
+const locStatisticsGatherer = agent({
+  model: "small",
+  instructions: p`Count lines of code across the workspace grouped by file extension.
+
+Find source files and count lines:
+${p.bash("find . -maxdepth 4 -type f \\( -name '*.ts' -o -name '*.js' -o -name '*.py' -o -name '*.go' -o -name '*.md' \\) ! -path '*/node_modules/*' ! -path '*/.git/*' | xargs wc -l 2>/dev/null | tail -n +1")}
+
+Use the aggregateByExtension tool to group by extension.
+Classify each extension's complexity based on total lineCount:
+- small: < 500, medium: 500-2000, large: 2000-10000, xlarge: > 10000
+Return s.record output keyed by extension with lineCount, fileCount, and complexity.`,
+  tools: [aggregateByExtension],
+  output: s.record(
+    s.object({
+      lineCount: s.int,
+      fileCount: s.int,
+      complexity: s.enum("small", "medium", "large", "xlarge"),
+    }),
+  ),
+});
+
+export default locStatisticsGatherer;
+```

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

@@ -0,0 +1,39 @@
+# 142 - Import Cycle Detector
+
+```rig
+import { agent, p, s } from "rig";
+import { repair } from "rig/addons";
+
+// Agent role: Detect import cycles in TypeScript source using madge and classify severity.
+const importCycleDetector = agent({
+  model: "small",
+  maxTurns: 3,
+  instructions: p`Detect circular import cycles in this TypeScript project.
+
+Run madge to find circular dependencies:
+${p.bash("npx madge --circular --json . 2>/dev/null || echo '[]'")}
+
+Also read the TypeScript config:
+${p.readOptional("tsconfig.json", "{}")}
+
+For each cycle found, classify severity:
+- high: cycle involves more than 3 files or includes entry points
+- medium: cycle involves 2-3 files
+- low: short cycle between utility files
+
+Return the structured output with hasCycles, cycles array, and totalCycles count.`,
+  addons: repair(),
+  output: s.object({
+    hasCycles: s.boolean,
+    cycles: s.array(
+      s.object({
+        path: s.array(s.string),
+        severity: s.enum("high", "medium", "low"),
+      }),
+    ),
+    totalCycles: s.int,
+  }),
+});
+
+export default importCycleDetector;
+```

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

@@ -0,0 +1,33 @@
+# 143 - Coverage Badge Updater
+
+```rig
+import { agent, p, s } from "rig";
+
+// Agent role: Update README.md with shields.io coverage badges from coverage summary JSON.
+const coverageBadgeUpdater = agent({
+  model: "small",
+  instructions: p`Read the coverage summary and generate shields.io badge markdown.
+
+Coverage summary:
+${p.readOptional("coverage/coverage-summary.json", "{}")}
+
+Compute coverage percentages per category (lines, statements, functions, branches) and overall.
+Generate shields.io badge markdown URL for each category.
+Classify overall coverage rating:
+- green: >= 80%, yellow: 50-79%, red: < 50%
+
+Write the badge summary markdown to README.md using the p.writeOutput intent below.
+${p.writeOutput("badgeSummary", "README.md")}
+
+Return coverageByCategory (record of percentages), overallPct, rating, badgesWritten, and badgeSummary.`,
+  output: s.object({
+    coverageByCategory: s.record(s.number),
+    overallPct: s.number,
+    rating: s.enum("green", "yellow", "red"),
+    badgesWritten: s.boolean,
+    badgeSummary: s.string,
+  }),
+});
+
+export default coverageBadgeUpdater;
+```

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

@@ -0,0 +1,54 @@
+# 144 - Dep License Auditor
+
+```rig
+import { agent, p, s, defineTool } from "rig";
+
+const extractLicense = defineTool("extractLicense", {
+  description: "Read license field from a package in node_modules.",
+  parameters: s.object({ packageName: s.string }),
+  async handler({ packageName }) {
+    const { readFileSync } = await import("node:fs");
+    try {
+      const pkgPath = `node_modules/${packageName}/package.json`;
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+      const license: string = pkg.license ?? pkg.licenses?.[0]?.type ?? "UNKNOWN";
+      let category: "permissive" | "copyleft" | "unknown" = "unknown";
+      const upper = license.toUpperCase();
+      if (["MIT", "ISC", "BSD", "APACHE", "0BSD", "WTFPL"].some(l => upper.includes(l))) {
+        category = "permissive";
+      } else if (["GPL", "LGPL", "AGPL", "MPL", "EUPL"].some(l => upper.includes(l))) {
+        category = "copyleft";
+      }
+      return { license, category };
+    } catch {
+      return { license: "UNKNOWN", category: "unknown" as const };
+    }
+  },
+});
+
+// Agent role: Audit dependency licenses and flag copyleft packages.
+const depLicenseAuditor = agent({
+  model: "small",
+  instructions: p`Audit dependency licenses for this project.
+
+List installed packages:
+${p.bash("npm ls --json --depth=0 2>/dev/null | node -e \"const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));console.log(Object.keys(d.dependencies||{}).join('\\n'))\" 2>/dev/null || ls node_modules | head -50")}
+
+For each package, use the extractLicense tool to get its license and category.
+Return packages array, hasCopyleft flag, and totalPackages count.`,
+  tools: [extractLicense],
+  output: s.object({
+    packages: s.array(
+      s.object({
+        name: s.string,
+        license: s.string,
+        category: s.enum("permissive", "copyleft", "unknown"),
+      }),
+    ),
+    hasCopyleft: s.boolean,
+    totalPackages: s.int,
+  }),
+});
+
+export default depLicenseAuditor;
+```

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

@@ -0,0 +1,56 @@
+# 145 - Test Coverage Mapper
+
+```rig
+import { agent, p, s, defineTool } from "rig";
+import { repair } from "rig/addons";
+
+const matchTestFile = defineTool("matchTestFile", {
+  description: "Heuristically find test files matching a source file by name.",
+  parameters: s.object({ sourcePath: s.string, testFiles: s.array(s.string) }),
+  handler({ sourcePath, testFiles }) {
+    const baseName = sourcePath.split("/").pop()!.replace(/\.ts$/, "");
+    const patterns = [
+      `${baseName}.test.ts`,
+      `${baseName}.spec.ts`,
+      `${baseName}.test.js`,
+      `${baseName}.spec.js`,
+    ];
+    const matched = testFiles.filter(f =>
+      patterns.some(p => f.endsWith(p))
+    );
+    return { matched };
+  },
+});
+
+// Agent role: Map source files to their test counterparts and classify coverage.
+const testCoverageMapper = agent({
+  model: "small",
+  maxTurns: 2,
+  instructions: p`Map source files to test files using filename heuristics.
+
+Source files:
+${p.bash("find . -type f -name '*.ts' ! -name '*.test.ts' ! -name '*.spec.ts' ! -path '*/node_modules/*' ! -path '*/.git/*' | head -40")}
+
+Test files:
+${p.bash("find . -type f \\( -name '*.test.ts' -o -name '*.spec.ts' \\) ! -path '*/node_modules/*' | head -40")}
+
+For each source file, use matchTestFile to find matching test files.
+Classify coverage:
+- covered: at least one test file matched
+- uncovered: no test files matched
+- partial: test file exists but may not cover all exports (use heuristics)
+
+Return s.record output keyed by source file path.`,
+  tools: [matchTestFile],
+  addons: repair(),
+  output: s.record(
+    s.object({
+      coverage: s.enum("covered", "uncovered", "partial"),
+      testFiles: s.array(s.string),
+      reason: s.string,
+    }),
+  ),
+});
+
+export default testCoverageMapper;
+```

skills/rig/samples/146-file-permission-scanner.md

@@ -0,0 +1,45 @@
+# 146 - File Permission Scanner
+
+```rig
+import { agent, p, s, defineTool } from "rig";
+
+const parsePermissions = defineTool("parsePermissions", {
+  description: "Parse a unix permission string and classify risk level.",
+  parameters: s.object({ permissions: s.string, filename: s.string }),
+  handler({ permissions }) {
+    const isExecutable = permissions[3] === "x" || permissions[6] === "x" || permissions[9] === "x";
+    const isWorldWritable = permissions[8] === "w";
+    let riskLevel: "safe" | "warn" | "danger" = "safe";
+    if (isWorldWritable) riskLevel = "danger";
+    else if (isExecutable) riskLevel = "warn";
+    return { isExecutable, isWorldWritable, riskLevel };
+  },
+});
+
+// Agent role: Scan workspace file permissions and flag dangerous or unusual access modes.
+const filePermissionScanner = agent({
+  model: "small",
+  instructions: p`Scan file permissions in the workspace and classify risk.
+
+List files with permissions:
+${p.bash("find . -maxdepth 3 -type f ! -path '*/node_modules/*' ! -path '*/.git/*' | head -50 | xargs ls -la 2>/dev/null")}
+
+For each file, use parsePermissions to determine isExecutable, isWorldWritable, and riskLevel.
+Return s.object with files record (keyed by filename), dangerCount, and allSafe.`,
+  tools: [parsePermissions],
+  output: s.object({
+    files: s.record(
+      s.object({
+        mode: s.string,
+        isExecutable: s.boolean,
+        isWorldWritable: s.boolean,
+        riskLevel: s.enum("safe", "warn", "danger"),
+      }),
+    ),
+    dangerCount: s.int,
+    allSafe: s.boolean,
+  }),
+});
+
+export default filePermissionScanner;
+```

skills/rig/samples/147-git-submodule-health.md

@@ -0,0 +1,53 @@
+# 147 - Git Submodule Health
+
+```rig
+import { agent, p, s, defineTool } from "rig";
+
+const parseSubmoduleStatus = defineTool("parseSubmoduleStatus", {
+  description: "Parse a git submodule status line into structured fields.",
+  parameters: s.object({ line: s.string }),
+  handler({ line }) {
+    const trimmed = line.trimStart();
+    if (!trimmed) return null;
+    const statusChar = line[0];
+    const rest = trimmed.replace(/^[\+\- U]/, "").trim();
+    const parts = rest.split(/\s+/);
+    const sha = parts[0] ?? "";
+    const path = parts[1] ?? "";
+    let status: "clean" | "modified" | "uninitialized" | "missing" = "clean";
+    if (statusChar === "+") status = "modified";
+    else if (statusChar === "-") status = "uninitialized";
+    else if (statusChar === "U") status = "missing";
+    return { path, sha, status };
+  },
+});
+
+// Agent role: Inventory git submodules and report their health status.
+const gitSubmoduleHealth = agent({
+  model: "small",
+  instructions: p`Check the health of all git submodules in this repository.
+
+Submodule status:
+${p.bash("git submodule status 2>/dev/null || echo '(no submodules)'")}
+
+Submodule config:
+${p.readOptional(".gitmodules", "(no .gitmodules file)")}
+
+For each status line, use parseSubmoduleStatus to extract path, sha, and status.
+Return submodules array, allClean flag, and totalCount.`,
+  tools: [parseSubmoduleStatus],
+  output: s.object({
+    submodules: s.array(
+      s.object({
+        path: s.string,
+        sha: s.string,
+        status: s.enum("clean", "modified", "uninitialized", "missing"),
+      }),
+    ),
+    allClean: s.boolean,
+    totalCount: s.int,
+  }),
+});
+
+export default gitSubmoduleHealth;
+```