csharp-code-calisthenics-reviewer 0.1.0

package/.agents/plugins/marketplace.json

@@ -0,0 +1,20 @@
+{
+  "name": "local-marketplace",
+  "interface": {
+    "displayName": "Local Plugins"
+  },
+  "plugins": [
+    {
+      "name": "csharp-code-calisthenics-reviewer",
+      "source": {
+        "source": "local",
+        "path": "./plugins/csharp-code-calisthenics-reviewer"
+      },
+      "policy": {
+        "installation": "AVAILABLE",
+        "authentication": "ON_INSTALL"
+      },
+      "category": "Productivity"
+    }
+  ]
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Leonardo de Oliveira
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,118 @@
+# csharp-code-calisthenics-reviewer
+
+`csharp-code-calisthenics-reviewer` is an npm-distributed skill package for reviewing a single C# file or small class against a narrow set of code-calisthenics rules and suggesting a deterministic refactor plan.
+
+## What v1 reviews
+
+The skill checks exactly these 5 rules:
+
+- Only one level of indentation per method
+- Avoid `else`
+- Wrap primitives in value objects when it makes sense
+- First-class collections
+- Small methods with intention-revealing names
+
+The skill is instruction-heavy by design. It does not perform full automatic rewrites by default, but it may include short illustrative snippets when they clarify a proposed refactor.
+
+## Repo layout
+
+```text
+src/
+  raw-skill/
+    SKILL.md
+    references/calisthenics-checklist.md
+    examples/input/OrderService.cs
+    examples/output/review.md
+  codex-plugin/
+    .codex-plugin/plugin.json
+    skills/csharp-code-calisthenics-reviewer/
+bin/
+  installer.js
+scripts/
+  build.js
+.agents/
+  plugins/marketplace.json
+```
+
+`src/raw-skill` is the canonical source. `npm run build` mirrors it into the Codex plugin skill folder and synchronizes the plugin manifest version from `package.json`.
+
+## Install
+
+### npm / npx
+
+Build first:
+
+```bash
+npm install
+npm run build
+```
+
+Run from the published package or locally:
+
+```bash
+npx csharp-code-calisthenics-reviewer install --target codex --scope personal
+npx csharp-code-calisthenics-reviewer install --target codex --scope repo --path /path/to/repo
+npx csharp-code-calisthenics-reviewer install --target dir --path /path/to/destination
+npx csharp-code-calisthenics-reviewer install --target claude --path /path/to/destination
+```
+
+Optional flags:
+
+```bash
+--dry-run
+--force
+```
+
+### Skillfish
+
+Use the raw skill bundle:
+
+```bash
+npx csharp-code-calisthenics-reviewer install --target dir --path /path/to/skills/csharp-code-calisthenics-reviewer
+```
+
+### Codex local plugin install
+
+Personal install:
+
+```bash
+npx csharp-code-calisthenics-reviewer install --target codex --scope personal
+```
+
+This installs the plugin to `~/.codex/plugins/csharp-code-calisthenics-reviewer` and creates or updates `~/.agents/plugins/marketplace.json`.
+
+Repo install:
+
+```bash
+npx csharp-code-calisthenics-reviewer install --target codex --scope repo --path /path/to/repo
+```
+
+This installs the plugin to `<repo>/plugins/csharp-code-calisthenics-reviewer` and creates or updates `<repo>/.agents/plugins/marketplace.json`.
+
+### Claude-compatible path copy
+
+```bash
+npx csharp-code-calisthenics-reviewer install --target claude --path /path/to/destination
+```
+
+This performs an explicit path-based copy only. v1 does not assume or document an official Claude install location.
+
+## Build and verify
+
+```bash
+npm run build
+python C:/Users/USUARIO/.codex/skills/.system/skill-creator/scripts/quick_validate.py src/raw-skill
+npm pack
+```
+
+On Windows PowerShell, if `npm pack` is blocked by `npm.ps1` execution policy or by the global npm cache, use:
+
+```powershell
+npm run pack:ps
+```
+
+## Marketplace metadata
+
+The Codex plugin manifest lives at `src/codex-plugin/.codex-plugin/plugin.json`.
+
+The repository also includes `.agents/plugins/marketplace.json` as a repo-local marketplace catalog entry that points to `./plugins/csharp-code-calisthenics-reviewer`. Installer runs generate or update marketplace entries at the chosen destination without duplicating existing entries.

package/bin/installer.js

@@ -0,0 +1,328 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const PLUGIN_NAME = "csharp-code-calisthenics-reviewer";
+const DEFAULT_ENTRY = {
+  name: PLUGIN_NAME,
+  source: {
+    source: "local",
+    path: `./plugins/${PLUGIN_NAME}`
+  },
+  policy: {
+    installation: "AVAILABLE",
+    authentication: "ON_INSTALL"
+  },
+  category: "Productivity"
+};
+
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+function parseArgs(argv) {
+  const parsed = {
+    command: null,
+    target: null,
+    scope: null,
+    path: null,
+    force: false,
+    dryRun: false
+  };
+
+  const tokens = [...argv];
+  if (tokens.length > 0 && !tokens[0].startsWith("--")) {
+    parsed.command = tokens.shift();
+  }
+
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    switch (token) {
+      case "--target":
+        parsed.target = tokens[++index];
+        break;
+      case "--scope":
+        parsed.scope = tokens[++index];
+        break;
+      case "--path":
+        parsed.path = tokens[++index];
+        break;
+      case "--force":
+        parsed.force = true;
+        break;
+      case "--dry-run":
+        parsed.dryRun = true;
+        break;
+      default:
+        fail(`Unknown argument: ${token}`);
+    }
+  }
+
+  return parsed;
+}
+
+function resolvePackageRoot() {
+  return path.resolve(__dirname, "..");
+}
+
+function ensureExists(targetPath, label) {
+  if (!fs.existsSync(targetPath)) {
+    fail(`${label} not found: ${targetPath}. Run "npm run build" before installing.`);
+  }
+}
+
+function readJson(filePath, fallback) {
+  if (!fs.existsSync(filePath)) {
+    return fallback;
+  }
+
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function writeJson(filePath, value, dryRun) {
+  const payload = `${JSON.stringify(value, null, 2)}\n`;
+  if (dryRun) {
+    console.log(`[dry-run] write ${filePath}`);
+    return;
+  }
+
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, payload, "utf8");
+}
+
+function removeDir(targetPath, dryRun) {
+  if (!fs.existsSync(targetPath)) {
+    return;
+  }
+
+  if (dryRun) {
+    console.log(`[dry-run] remove ${targetPath}`);
+    return;
+  }
+
+  fs.rmSync(targetPath, { recursive: true, force: true });
+}
+
+function listFiles(rootPath) {
+  const results = [];
+
+  function visit(currentPath) {
+    const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolutePath = path.join(currentPath, entry.name);
+      if (entry.isDirectory()) {
+        visit(absolutePath);
+      } else {
+        results.push(path.relative(rootPath, absolutePath));
+      }
+    }
+  }
+
+  visit(rootPath);
+  return results.sort();
+}
+
+function directoriesMatch(sourcePath, destinationPath) {
+  if (!fs.existsSync(sourcePath) || !fs.existsSync(destinationPath)) {
+    return false;
+  }
+
+  const sourceFiles = listFiles(sourcePath);
+  const destinationFiles = listFiles(destinationPath);
+  if (sourceFiles.length !== destinationFiles.length) {
+    return false;
+  }
+
+  for (let index = 0; index < sourceFiles.length; index += 1) {
+    if (sourceFiles[index] !== destinationFiles[index]) {
+      return false;
+    }
+
+    const sourceContent = fs.readFileSync(path.join(sourcePath, sourceFiles[index]), "utf8");
+    const destinationContent = fs.readFileSync(path.join(destinationPath, destinationFiles[index]), "utf8");
+    if (sourceContent !== destinationContent) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function copyDir(sourcePath, destinationPath, options) {
+  const { dryRun } = options;
+  if (dryRun) {
+    console.log(`[dry-run] copy ${sourcePath} -> ${destinationPath}`);
+    return;
+  }
+
+  fs.mkdirSync(destinationPath, { recursive: true });
+  fs.cpSync(sourcePath, destinationPath, { recursive: true });
+}
+
+function copyIntoDestination(sourcePath, destinationPath, options) {
+  const { force, dryRun } = options;
+  const destinationExists = fs.existsSync(destinationPath);
+
+  if (destinationExists && !force) {
+    if (directoriesMatch(sourcePath, destinationPath)) {
+      console.log(`Destination already matches source: ${destinationPath}`);
+      return "unchanged";
+    }
+
+    fail(`Destination already exists and differs: ${destinationPath}. Re-run with --force to overwrite.`);
+  }
+
+  if (destinationExists) {
+    removeDir(destinationPath, dryRun);
+  }
+
+  copyDir(sourcePath, destinationPath, options);
+  return dryRun ? "dry-run" : "copied";
+}
+
+function ensureMarketplaceShape(marketplace) {
+  const next = marketplace ?? {};
+  if (typeof next.name !== "string") {
+    next.name = "local-marketplace";
+  }
+
+  if (!next.interface || typeof next.interface !== "object") {
+    next.interface = { displayName: "Local Plugins" };
+  }
+
+  if (typeof next.interface.displayName !== "string") {
+    next.interface.displayName = "Local Plugins";
+  }
+
+  if (!Array.isArray(next.plugins)) {
+    next.plugins = [];
+  }
+
+  return next;
+}
+
+function updateMarketplace(marketplacePath, entry, dryRun) {
+  const marketplace = ensureMarketplaceShape(readJson(marketplacePath, null));
+  const existingIndex = marketplace.plugins.findIndex((plugin) => plugin.name === entry.name);
+
+  if (existingIndex >= 0) {
+    marketplace.plugins[existingIndex] = entry;
+  } else {
+    marketplace.plugins.push(entry);
+  }
+
+  writeJson(marketplacePath, marketplace, dryRun);
+}
+
+function installCodex(scope, repoPath, options) {
+  const packageRoot = resolvePackageRoot();
+  const pluginSource = path.join(packageRoot, "src", "codex-plugin");
+  ensureExists(pluginSource, "Built Codex plugin");
+
+  let pluginDestination;
+  let marketplacePath;
+  let entry;
+
+  if (scope === "personal") {
+    const homeDir = os.homedir();
+    pluginDestination = path.join(homeDir, ".codex", "plugins", PLUGIN_NAME);
+    marketplacePath = path.join(homeDir, ".agents", "plugins", "marketplace.json");
+    entry = {
+      ...DEFAULT_ENTRY,
+      source: {
+        source: "local",
+        path: pluginDestination
+      }
+    };
+  } else if (scope === "repo") {
+    if (!repoPath) {
+      fail('Missing required "--path" for repo-scoped Codex install.');
+    }
+
+    const repoRoot = path.resolve(repoPath);
+    pluginDestination = path.join(repoRoot, "plugins", PLUGIN_NAME);
+    marketplacePath = path.join(repoRoot, ".agents", "plugins", "marketplace.json");
+    entry = { ...DEFAULT_ENTRY };
+  } else {
+    fail('Codex installs require "--scope personal" or "--scope repo".');
+  }
+
+  const status = copyIntoDestination(pluginSource, pluginDestination, options);
+  updateMarketplace(marketplacePath, entry, options.dryRun);
+
+  if (status === "dry-run") {
+    console.log(`Dry-run completed for Codex plugin destination ${pluginDestination}`);
+  } else if (status === "unchanged") {
+    console.log(`Codex plugin already up to date at ${pluginDestination}`);
+  } else {
+    console.log(`Installed Codex plugin to ${pluginDestination}`);
+  }
+
+  console.log(`${options.dryRun ? "Dry-run updated" : "Updated"} marketplace at ${marketplacePath}`);
+}
+
+function installRawSkill(targetPath, options, label) {
+  const packageRoot = resolvePackageRoot();
+  const rawSkillSource = path.join(packageRoot, "src", "raw-skill");
+  ensureExists(rawSkillSource, "Raw skill bundle");
+
+  if (!targetPath) {
+    fail('Missing required "--path" for this install target.');
+  }
+
+  const destination = path.resolve(targetPath);
+  const status = copyIntoDestination(rawSkillSource, destination, options);
+  if (status === "dry-run") {
+    console.log(`Dry-run completed for ${label} destination ${destination}`);
+    return;
+  }
+
+  if (status === "unchanged") {
+    console.log(`${label} bundle already up to date at ${destination}`);
+    return;
+  }
+
+  console.log(`Installed ${label} bundle to ${destination}`);
+}
+
+function printUsageAndExit() {
+  const lines = [
+    "Usage:",
+    "  csharp-code-calisthenics-reviewer install --target codex --scope personal [--force] [--dry-run]",
+    "  csharp-code-calisthenics-reviewer install --target codex --scope repo --path <repo-root> [--force] [--dry-run]",
+    "  csharp-code-calisthenics-reviewer install --target dir --path <destination> [--force] [--dry-run]",
+    "  csharp-code-calisthenics-reviewer install --target claude --path <destination> [--force] [--dry-run]"
+  ];
+
+  console.log(lines.join("\n"));
+  process.exit(1);
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (args.command !== "install" || !args.target) {
+    printUsageAndExit();
+  }
+
+  const options = { force: args.force, dryRun: args.dryRun };
+
+  switch (args.target) {
+    case "codex":
+      installCodex(args.scope, args.path, options);
+      break;
+    case "dir":
+      installRawSkill(args.path, options, "raw skill");
+      break;
+    case "claude":
+      installRawSkill(args.path, options, "Claude-compatible");
+      break;
+    default:
+      fail(`Unsupported target: ${args.target}`);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "csharp-code-calisthenics-reviewer",
+  "version": "0.1.0",
+  "description": "Deterministic C# code calisthenics review skill packaged as a raw skill bundle and Codex plugin.",
+  "license": "MIT",
+  "bin": {
+    "csharp-code-calisthenics-reviewer": "./bin/installer.js"
+  },
+  "scripts": {
+    "build": "node scripts/build.js",
+    "pack:ps": "powershell -NoProfile -ExecutionPolicy Bypass -Command \"$env:npm_config_cache=(Get-Location).Path + '\\.tmp\\npm-cache'; npm.cmd pack\""
+  },
+  "files": [
+    "src/raw-skill/**",
+    "src/codex-plugin/**",
+    "scripts/build.js",
+    "bin/installer.js",
+    "README.md",
+    "LICENSE",
+    ".agents/plugins/marketplace.json"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}

package/scripts/build.js

@@ -0,0 +1,110 @@
+const fs = require("fs");
+const path = require("path");
+
+const PLUGIN_NAME = "csharp-code-calisthenics-reviewer";
+const REQUIRED_SKILL_FILES = [
+  "SKILL.md",
+  path.join("references", "calisthenics-checklist.md"),
+  path.join("examples", "input", "OrderService.cs"),
+  path.join("examples", "output", "review.md")
+];
+
+function fail(message) {
+  throw new Error(message);
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+function listFiles(rootPath) {
+  const results = [];
+
+  function visit(currentPath) {
+    const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolutePath = path.join(currentPath, entry.name);
+      const relativePath = path.relative(rootPath, absolutePath);
+      if (entry.isDirectory()) {
+        visit(absolutePath);
+      } else {
+        results.push(relativePath);
+      }
+    }
+  }
+
+  visit(rootPath);
+  return results.sort();
+}
+
+function assertRequiredFiles(rootPath) {
+  for (const relativePath of REQUIRED_SKILL_FILES) {
+    const absolutePath = path.join(rootPath, relativePath);
+    if (!fs.existsSync(absolutePath)) {
+      fail(`Required skill file is missing: ${absolutePath}`);
+    }
+  }
+}
+
+function copyDir(sourcePath, destinationPath) {
+  fs.rmSync(destinationPath, { recursive: true, force: true });
+  fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+  fs.cpSync(sourcePath, destinationPath, { recursive: true });
+}
+
+function assertParity(sourcePath, destinationPath) {
+  const sourceFiles = listFiles(sourcePath);
+  const destinationFiles = listFiles(destinationPath);
+  const sourceJoined = sourceFiles.join("\n");
+  const destinationJoined = destinationFiles.join("\n");
+
+  if (sourceJoined !== destinationJoined) {
+    fail("Raw skill and plugin skill file lists differ after build.");
+  }
+
+  for (const relativePath of sourceFiles) {
+    const sourceContent = fs.readFileSync(path.join(sourcePath, relativePath), "utf8");
+    const destinationContent = fs.readFileSync(path.join(destinationPath, relativePath), "utf8");
+    if (sourceContent !== destinationContent) {
+      fail(`Skill parity mismatch after build: ${relativePath}`);
+    }
+  }
+}
+
+function syncPluginManifest(packageRoot) {
+  const packageJsonPath = path.join(packageRoot, "package.json");
+  const pluginJsonPath = path.join(packageRoot, "src", "codex-plugin", ".codex-plugin", "plugin.json");
+  const packageJson = readJson(packageJsonPath);
+  const pluginJson = readJson(pluginJsonPath);
+
+  pluginJson.name = PLUGIN_NAME;
+  pluginJson.version = packageJson.version;
+  pluginJson.skills = "./skills/";
+
+  writeJson(pluginJsonPath, pluginJson);
+
+  const reloaded = readJson(pluginJsonPath);
+  if (reloaded.version !== packageJson.version) {
+    fail("Plugin manifest version did not match package.json after synchronization.");
+  }
+}
+
+function main() {
+  const packageRoot = path.resolve(__dirname, "..");
+  const rawSkillRoot = path.join(packageRoot, "src", "raw-skill");
+  const pluginSkillRoot = path.join(packageRoot, "src", "codex-plugin", "skills", PLUGIN_NAME);
+
+  assertRequiredFiles(rawSkillRoot);
+  copyDir(rawSkillRoot, pluginSkillRoot);
+  assertParity(rawSkillRoot, pluginSkillRoot);
+  syncPluginManifest(packageRoot);
+
+  console.log("Build completed successfully.");
+}
+
+main();

package/src/codex-plugin/.codex-plugin/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "csharp-code-calisthenics-reviewer",
+  "version": "0.1.0",
+  "description": "Review a C# file or small class against a fixed set of code-calisthenics rules and suggest a refactor plan.",
+  "skills": "./skills/"
+}

package/src/codex-plugin/skills/csharp-code-calisthenics-reviewer/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: csharp-code-calisthenics-reviewer
+description: Review a single C# file or small C# class against a fixed, narrow set of code-calisthenics rules and produce a deterministic refactor plan. Use when asked to critique or review C# code for indentation depth, else usage, primitive obsession, missing first-class collections, and overly large or poorly named methods.
+---
+
+# C# Code Calisthenics Reviewer
+
+Review one C# file or one small class at a time. Keep the review narrow, deterministic, and grounded in the provided code.
+
+## Rules
+
+Check only these 5 rules:
+
+1. Only one level of indentation per method
+2. Avoid `else`
+3. Wrap primitives in value objects when it makes sense
+4. First-class collections
+5. Small methods with intention-revealing names
+
+Do not expand into the broader code-calisthenics catalog unless the user explicitly asks for that.
+
+## Working style
+
+- Read the code carefully before judging it.
+- Stay concrete and repeatable. Do not use random scoring, vague style commentary, or speculative claims.
+- Base every finding on visible code in the provided file or class.
+- Mention guard-clause opportunities when they help flatten control flow.
+- Do not perform a full automatic rewrite by default.
+- Include a short illustrative snippet only when it makes a recommendation easier to understand.
+
+## Review process
+
+1. Identify the class or methods under review.
+2. Evaluate each of the 5 rules in order.
+3. Record only the findings that are supported by the code.
+4. Prioritize issues that reduce nesting, split responsibilities, and clarify domain language.
+5. End with a refactor plan ordered by highest leverage first.
+
+## Output format
+
+Use this structure:
+
+### Findings
+
+For each rule:
+
+- `Rule:` the exact rule name
+- `Assessment:` `Pass`, `Concern`, or `Not applicable`
+- `Evidence:` a brief code-specific explanation
+- `Suggestion:` one concrete next step
+
+### Refactor plan
+
+Provide 3 to 6 ordered steps. Each step should describe a refactor action, not just a diagnosis.
+
+### Optional snippet
+
+Only include this section when a very short snippet clarifies one suggested refactor. Keep it focused on one change, not a full rewritten file.
+
+## References
+
+- Read `references/calisthenics-checklist.md` for the review checklist and refactor priorities.
+- Use `examples/input/OrderService.cs` and `examples/output/review.md` as the canonical example of expected scope and output shape.

package/src/codex-plugin/skills/csharp-code-calisthenics-reviewer/examples/input/OrderService.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Example;
+
+public class OrderService
+{
+    public void Process(List<Order> orders, decimal discountRate, string customerType)
+    {
+        if (orders == null)
+        {
+            throw new ArgumentNullException(nameof(orders));
+        }
+        else
+        {
+            foreach (var order in orders)
+            {
+                if (order.Total > 100)
+                {
+                    if (customerType == "VIP")
+                    {
+                        order.Total = order.Total - (order.Total * discountRate);
+                    }
+                    else
+                    {
+                        order.Total = order.Total - 5;
+                    }
+                }
+            }
+
+            Save(orders);
+            Notify(customerType, orders.Count);
+        }
+    }
+
+    private void Save(List<Order> orders)
+    {
+        Console.WriteLine($"Saved {orders.Count} orders.");
+    }
+
+    private void Notify(string customerType, int orderCount)
+    {
+        Console.WriteLine($"Notified {customerType} customer about {orderCount} orders.");
+    }
+}
+
+public class Order
+{
+    public decimal Total { get; set; }
+}

package/src/codex-plugin/skills/csharp-code-calisthenics-reviewer/examples/output/review.md

@@ -0,0 +1,43 @@
+# Findings
+
+- Rule: Only one level of indentation per method
+  Assessment: Concern
+  Evidence: `Process` nests a null check, a `foreach`, an order-total condition, and a customer-type condition. The deepest branch goes well beyond one indentation level.
+  Suggestion: Use a guard clause for `orders == null`, then extract the discount decision into a separate method or policy object.
+
+- Rule: Avoid `else`
+  Assessment: Concern
+  Evidence: `Process` contains an `else` after the null check and another `else` inside the discount logic.
+  Suggestion: Replace both branches with guard clauses or early returns so the happy path stays flat.
+
+- Rule: Wrap primitives in value objects when it makes sense
+  Assessment: Concern
+  Evidence: `discountRate` and `customerType` carry domain meaning but are represented as raw `decimal` and `string`.
+  Suggestion: Introduce value objects such as `DiscountRate` and `CustomerType` to make valid states explicit.
+
+- Rule: First-class collections
+  Assessment: Concern
+  Evidence: `List<Order>` is passed through `Process` and `Save` as a raw collection with behavior spread across the service.
+  Suggestion: Introduce an `OrderBatch` or similar collection abstraction to hold iteration and batch-level behavior.
+
+- Rule: Small methods with intention-revealing names
+  Assessment: Concern
+  Evidence: `Process` validates input, applies pricing rules, persists data, and sends notifications. The name is broad and hides multiple responsibilities.
+  Suggestion: Split the work into smaller methods with explicit names such as `ApplyDiscounts`, `SaveBatch`, and `NotifyCustomer`.
+
+# Refactor plan
+
+1. Replace the outer `if/else` with a guard clause so `Process` starts with the valid path.
+2. Extract discount selection into a small method or domain object to remove nested conditional logic.
+3. Introduce value objects for `CustomerType` and `DiscountRate` to replace raw primitives.
+4. Replace raw `List<Order>` parameters with an `OrderBatch` collection abstraction.
+5. Split `Process` into smaller methods whose names reveal validation, pricing, persistence, and notification separately.
+
+# Optional snippet
+
+```csharp
+if (orders is null)
+{
+    throw new ArgumentNullException(nameof(orders));
+}
+```

package/src/codex-plugin/skills/csharp-code-calisthenics-reviewer/references/calisthenics-checklist.md

@@ -0,0 +1,17 @@
+# Code Calisthenics Checklist
+
+## Core checks
+- More than one indentation level inside a method?
+- Any else blocks?
+- Any primitive obsession?
+- Any collection passed around without its own abstraction?
+- Any method doing more than one thing?
+- Any name that hides domain meaning?
+- Any obvious guard clause missing?
+
+## Refactor priorities
+1. Flatten control flow
+2. Extract domain concepts
+3. Improve names
+4. Separate responsibilities
+5. Reduce incidental complexity

package/src/raw-skill/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: csharp-code-calisthenics-reviewer
+description: Review a single C# file or small C# class against a fixed, narrow set of code-calisthenics rules and produce a deterministic refactor plan. Use when asked to critique or review C# code for indentation depth, else usage, primitive obsession, missing first-class collections, and overly large or poorly named methods.
+---
+
+# C# Code Calisthenics Reviewer
+
+Review one C# file or one small class at a time. Keep the review narrow, deterministic, and grounded in the provided code.
+
+## Rules
+
+Check only these 5 rules:
+
+1. Only one level of indentation per method
+2. Avoid `else`
+3. Wrap primitives in value objects when it makes sense
+4. First-class collections
+5. Small methods with intention-revealing names
+
+Do not expand into the broader code-calisthenics catalog unless the user explicitly asks for that.
+
+## Working style
+
+- Read the code carefully before judging it.
+- Stay concrete and repeatable. Do not use random scoring, vague style commentary, or speculative claims.
+- Base every finding on visible code in the provided file or class.
+- Mention guard-clause opportunities when they help flatten control flow.
+- Do not perform a full automatic rewrite by default.
+- Include a short illustrative snippet only when it makes a recommendation easier to understand.
+
+## Review process
+
+1. Identify the class or methods under review.
+2. Evaluate each of the 5 rules in order.
+3. Record only the findings that are supported by the code.
+4. Prioritize issues that reduce nesting, split responsibilities, and clarify domain language.
+5. End with a refactor plan ordered by highest leverage first.
+
+## Output format
+
+Use this structure:
+
+### Findings
+
+For each rule:
+
+- `Rule:` the exact rule name
+- `Assessment:` `Pass`, `Concern`, or `Not applicable`
+- `Evidence:` a brief code-specific explanation
+- `Suggestion:` one concrete next step
+
+### Refactor plan
+
+Provide 3 to 6 ordered steps. Each step should describe a refactor action, not just a diagnosis.
+
+### Optional snippet
+
+Only include this section when a very short snippet clarifies one suggested refactor. Keep it focused on one change, not a full rewritten file.
+
+## References
+
+- Read `references/calisthenics-checklist.md` for the review checklist and refactor priorities.
+- Use `examples/input/OrderService.cs` and `examples/output/review.md` as the canonical example of expected scope and output shape.

package/src/raw-skill/examples/input/OrderService.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Example;
+
+public class OrderService
+{
+    public void Process(List<Order> orders, decimal discountRate, string customerType)
+    {
+        if (orders == null)
+        {
+            throw new ArgumentNullException(nameof(orders));
+        }
+        else
+        {
+            foreach (var order in orders)
+            {
+                if (order.Total > 100)
+                {
+                    if (customerType == "VIP")
+                    {
+                        order.Total = order.Total - (order.Total * discountRate);
+                    }
+                    else
+                    {
+                        order.Total = order.Total - 5;
+                    }
+                }
+            }
+
+            Save(orders);
+            Notify(customerType, orders.Count);
+        }
+    }
+
+    private void Save(List<Order> orders)
+    {
+        Console.WriteLine($"Saved {orders.Count} orders.");
+    }
+
+    private void Notify(string customerType, int orderCount)
+    {
+        Console.WriteLine($"Notified {customerType} customer about {orderCount} orders.");
+    }
+}
+
+public class Order
+{
+    public decimal Total { get; set; }
+}

package/src/raw-skill/examples/output/review.md

@@ -0,0 +1,43 @@
+# Findings
+
+- Rule: Only one level of indentation per method
+  Assessment: Concern
+  Evidence: `Process` nests a null check, a `foreach`, an order-total condition, and a customer-type condition. The deepest branch goes well beyond one indentation level.
+  Suggestion: Use a guard clause for `orders == null`, then extract the discount decision into a separate method or policy object.
+
+- Rule: Avoid `else`
+  Assessment: Concern
+  Evidence: `Process` contains an `else` after the null check and another `else` inside the discount logic.
+  Suggestion: Replace both branches with guard clauses or early returns so the happy path stays flat.
+
+- Rule: Wrap primitives in value objects when it makes sense
+  Assessment: Concern
+  Evidence: `discountRate` and `customerType` carry domain meaning but are represented as raw `decimal` and `string`.
+  Suggestion: Introduce value objects such as `DiscountRate` and `CustomerType` to make valid states explicit.
+
+- Rule: First-class collections
+  Assessment: Concern
+  Evidence: `List<Order>` is passed through `Process` and `Save` as a raw collection with behavior spread across the service.
+  Suggestion: Introduce an `OrderBatch` or similar collection abstraction to hold iteration and batch-level behavior.
+
+- Rule: Small methods with intention-revealing names
+  Assessment: Concern
+  Evidence: `Process` validates input, applies pricing rules, persists data, and sends notifications. The name is broad and hides multiple responsibilities.
+  Suggestion: Split the work into smaller methods with explicit names such as `ApplyDiscounts`, `SaveBatch`, and `NotifyCustomer`.
+
+# Refactor plan
+
+1. Replace the outer `if/else` with a guard clause so `Process` starts with the valid path.
+2. Extract discount selection into a small method or domain object to remove nested conditional logic.
+3. Introduce value objects for `CustomerType` and `DiscountRate` to replace raw primitives.
+4. Replace raw `List<Order>` parameters with an `OrderBatch` collection abstraction.
+5. Split `Process` into smaller methods whose names reveal validation, pricing, persistence, and notification separately.
+
+# Optional snippet
+
+```csharp
+if (orders is null)
+{
+    throw new ArgumentNullException(nameof(orders));
+}
+```

package/src/raw-skill/references/calisthenics-checklist.md

@@ -0,0 +1,17 @@
+# Code Calisthenics Checklist
+
+## Core checks
+- More than one indentation level inside a method?
+- Any else blocks?
+- Any primitive obsession?
+- Any collection passed around without its own abstraction?
+- Any method doing more than one thing?
+- Any name that hides domain meaning?
+- Any obvious guard clause missing?
+
+## Refactor priorities
+1. Flatten control flow
+2. Extract domain concepts
+3. Improve names
+4. Separate responsibilities
+5. Reduce incidental complexity