code-review-pro-skill 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Adrian Garcia
+
+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,216 @@
+# Code Review Pro
+
+A modular code review toolkit that separates:
+
+- **Enforcement** → deterministic clean code transformations  
+- **Review** → high-signal, risk-based feedback  
+
+---
+
+## 🧠 Why This Exists
+
+Most AI code review tools are:
+
+- noisy  
+- inconsistent  
+- overly mechanical  
+
+This system separates responsibilities to produce:
+
+- high-signal feedback  
+- predictable transformations  
+- consistent behavior  
+
+---
+
+## ⚙️ Skills
+
+### 1. clean-code-enforcer
+Deterministic refactoring engine for clean code enforcement.
+
+- rule-driven  
+- consistent output  
+- safe for automation  
+
+---
+
+### 2. senior-code-reviewer
+Senior-level reviewer focused on:
+
+- architecture  
+- risk  
+- prioritization  
+
+Surfaces only what actually matters.
+
+---
+
+## Supported Assistants
+
+- Codex
+- Claude
+- GitHub Copilot
+
+## Installation
+
+```bash
+git clone https://github.com/agarc179/code-review-system
+cd code-review-system
+npm install
+```
+
+### Local Development
+
+Link the CLI locally:
+
+```bash
+npm link
+```
+
+Then install the skills you want:
+
+```bash
+codepro init --ai codex --global
+codepro init --ai claude
+codepro init --ai githubcopilot
+```
+
+You can also install all supported assistants in one command:
+
+```bash
+codepro init --ai all
+```
+
+### Codex Shortcut
+
+If you only want the old Codex global install behavior:
+
+```bash
+./install.sh
+```
+
+### Published Usage
+
+After you publish this package to npm under your chosen package name, the install flow becomes:
+
+```bash
+npm install -g <your-package-name>
+codepro init --ai codex --global
+```
+
+## Install Targets
+
+- Codex: `~/.codex/skills` with `--global`, or `.codex/skills` in the target project
+- Claude: `~/.claude/skills` with `--global`, or `.claude/skills` in the target project
+- GitHub Copilot: `.github/prompts/*.prompt.md` and `.github/copilot-instructions.md` in the target project
+
+Each assistant is installed through its native route. This project does not force one fake universal format across Codex, Claude, and GitHub Copilot.
+
+GitHub Copilot is intentionally project-scoped in this CLI. Pretending there is one clean global file-based install path would be sloppy.
+
+## Authoring Model
+
+Skills default to one canonical source:
+
+- `skills/<skill-name>/SKILL.md`
+
+Optional assistant-native overrides are supported when a target needs its own artifact:
+
+- `skills/<skill-name>/overrides/codex/skill/...`
+- `skills/<skill-name>/overrides/claude/skill/...`
+- `skills/<skill-name>/overrides/githubcopilot/prompt.md`
+- `skills/<skill-name>/overrides/githubcopilot/instructions.md`
+
+Installer behavior:
+
+- Codex: installs the override skill directory if present, otherwise installs the canonical skill folder
+- Claude: installs the override skill directory if present, otherwise installs the canonical skill folder
+- GitHub Copilot: uses `prompt.md` if present, otherwise generates a native prompt file from the canonical skill content
+
+Use overrides only when an assistant needs materially different instructions or a different native file format.
+
+---
+
+## 🧪 Usage
+
+### Choose the skill directly
+
+```
+Use the senior-code-reviewer.
+
+[describe what you want + paste code]
+```
+
+---
+
+### Example — Review
+
+```
+Use the senior-code-reviewer.
+
+review this code
+
+function getUserScore(user) {
+  if (!user) return null;
+
+  return user.actions.reduce((total, action) => {
+    return total + action.value;
+  }, 0);
+}
+```
+
+---
+
+### Example — Refactor
+
+```
+Use the clean-code-enforcer.
+
+refactor this function
+
+function getUserScore(user) {
+  if (!user) return null;
+
+  return user.actions.reduce((total, action) => {
+    return total + action.value;
+  }, 0);
+}
+```
+
+---
+
+### Direct Usage (optional)
+
+You can call skills directly:
+
+```
+Use the senior-code-reviewer.
+Use the clean-code-enforcer.
+```
+
+---
+
+## 🧱 Architecture
+
+```
+User Request
+     ↓
+ ┌─────────────────────┬─────────────────────┐
+ │                     │                     │
+clean-code-enforcer    senior-code-reviewer
+(transform)            (evaluate)
+```
+
+---
+
+## ⚠️ Important Notes
+
+- Skills are used directly based on intent  
+- Designed for JavaScript, TypeScript, and Python  
+- Default behavior prioritizes evaluation over transformation  
+
+---
+
+## 📄 License
+
+MIT License

package/bin/codepro.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("../src/cli");

package/install.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+set -e
+
+node ./src/cli.js init --ai codex --global

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "code-review-pro-skill",
+  "version": "0.1.2",
+  "description": "Portable code review skills for Codex, Claude, and GitHub Copilot.",
+  "license": "MIT",
+  "type": "commonjs",
+  "bin": {
+    "codepro": "bin/codepro.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "skills",
+    "skill.json",
+    "README.md",
+    "LICENSE",
+    "install.sh"
+  ],
+  "scripts": {
+    "init:codex": "node ./src/cli.js init --ai codex",
+    "test:smoke": "node ./src/cli.js --help"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/skill.json

@@ -0,0 +1,14 @@
+{
+  "name": "code-review-pro-skill",
+  "version": "0.1.0",
+  "bin": "codepro",
+  "skills": [
+    "clean-code-enforcer",
+    "senior-code-reviewer"
+  ],
+  "assistants": [
+    "codex",
+    "claude",
+    "githubcopilot"
+  ]
+}

package/skills/clean-code-enforcer/SKILL.md

@@ -0,0 +1,125 @@
+---
+name: clean-code-enforcer
+description: Enforce strict clean code standards for Python, Java, and TypeScript during code review, refactoring, and full rewrites. Use when requests include review code, refactor, clean this code, rewrite this function, strict cleanup, aggressive rewrite, or when Codex must produce deterministic clean-code transformations with structured critique or rewritten code.
+---
+
+# Clean Code Enforcer
+
+Load [references/rules.md](references/rules.md) before producing output. That file is the source of truth for enforcement criteria and failure conditions.
+
+## Operating Directive
+
+Enforce the rules by default. Do not negotiate them away. Override a rule only when it conflicts with clarity, correctness, or clearly intentional well-structured code. This override takes precedence over [references/rules.md](references/rules.md). Prefer rewriting over patching whenever the current structure fails the rule set.
+
+Be deterministic. For the same input, use the same cleanup order, decomposition strategy, naming pattern, and output shape.
+
+Do not explain clean-code theory. Diagnose, transform, and enforce.
+
+Prefer clarity over mechanical compliance.
+
+Do not rewrite across boundaries that may affect external contracts unless explicitly requested.
+
+## Severity Model
+
+Use severity labels exactly as follows:
+
+- High: correctness or major structural risk
+- Medium: maintainability issue
+- Low: minor clarity issue
+
+## Mode Selection
+
+Choose exactly one mode from the request and context.
+
+### Review Mode
+
+Use when the user asks to review, critique, audit, or identify problems without asking for rewritten code.
+
+Behavior:
+- Inspect the full provided scope before judging parts.
+- Identify architectural issues first: coupling, layering, and data flow, before local or stylistic issues.
+- Detect business rules embedded in transformation or mapping logic, including inline domain calculations and hardcoded behavioral thresholds. Treat these as structural issues and prioritize them before local issues, with Medium or High severity based on impact.
+- Report violations against the rule set only.
+- Do not rewrite code.
+- For each issue, include a short reason and impact. Reason must describe a concrete property of the code, such as duplication, mixed responsibilities, or unclear naming. Impact must describe a real engineering risk, such as harder changes, increased bug risk, or duplicated logic drift. Avoid rule-based phrasing.
+- If the file exceeds 150 lines, review by logical sections while keeping file-wide consistency in the critique.
+
+Required output:
+
+```text
+Issues:
+1. [High] ... Reason: ... Impact: ...
+2. [Medium] ... Reason: ... Impact: ...
+
+Fixes:
+- ...
+- ...
+```
+
+### Refactor Mode
+
+Use when the user asks to refactor, clean up, simplify, or enforce clean code while still wanting an explanation.
+
+Behavior:
+- Rewrite aggressively enough to satisfy every applicable rule.
+- Preserve external behavior unless the original behavior depends on mixed responsibilities or dead code.
+- If the file exceeds 150 lines, refactor by logical sections while keeping one naming, layering, and helper strategy across the file.
+
+Required output:
+
+```text
+Refactored Code:
+<code>
+
+Key Improvements:
+- ...
+- ...
+```
+
+### Rewrite Mode
+
+Use when the user asks to rewrite code, fully rewrite, or aggressively rewrite.
+
+Behavior:
+- Perform a full rewrite when needed to satisfy the rule set.
+- Optimize for clarity, separation of concerns, and deterministic structure.
+- Output code only.
+
+Required output:
+
+```text
+<code only>
+```
+
+## Execution Workflow
+
+Apply this sequence in every mode:
+
+1. Detect language and scope.
+2. Inspect the entire provided unit or file.
+3. Identify major architectural issues first: coupling, layering, data flow, and boundary leakage.
+4. Remove dead code, unreachable paths, and unused helpers.
+5. Split mixed responsibilities by boundary: parsing, validation, processing, formatting, output, IO.
+6. Extract duplicated logic, repeated predicates, and repeated formatting or validation steps.
+7. Flatten control flow to satisfy the nesting limit.
+8. Split oversized or multi-purpose units until each unit passes the responsibility test.
+9. Rename every surviving unit and variable to match domain role and effect.
+10. Normalize patterns so one problem uses one solution style per scope.
+11. Recheck the rule set and emit only the selected mode output.
+
+## Scope Rules
+
+For input larger than 150 lines:
+- Review or refactor the entire file unless the user explicitly limits scope.
+- Partition the file into logical sections.
+- Remove duplication across sections, not only within sections.
+- Keep one naming and structural strategy across the whole scope.
+
+## Failure Handling
+
+If code is incomplete or ambiguous:
+- In Review Mode, report violations visible in the provided code only.
+- In Refactor Mode, refactor the visible code conservatively while still enforcing every applicable rule.
+- In Rewrite Mode, produce the cleanest valid rewrite that can be justified from the visible intent.
+
+Do not block on missing context unless correctness depends on an external contract that cannot be inferred.

package/skills/clean-code-enforcer/agents/openai.yaml

@@ -0,0 +1,3 @@
+name: clean-code-enforcer
+description: Deterministic clean code transformation engine for JavaScript, TypeScript, and Python
+entrypoint: SKILL.md

package/skills/clean-code-enforcer/references/rules.md

@@ -0,0 +1,181 @@
+# Clean Code Rules
+
+## Enforcement Model
+
+Apply every rule strictly. A unit fails if any applicable rule fails. Do not preserve violations for convenience, backward familiarity, or local style preference.
+
+Prefer deletion, extraction, and decomposition over commentary. If code can only be justified by explanation, the code is not clean enough.
+
+## Readability
+
+Code must be understandable in one pass.
+
+Fail when any of these are true:
+- A name does not reveal domain role, business meaning, or side effect.
+- A reader must inspect distant code to understand the basic purpose of a unit.
+- A unit mixes multiple abstraction levels, such as policy decisions beside low-level data shuffling.
+- A comment explains what the code should already make obvious.
+
+Enforce:
+- Use explicit, intention-revealing names for functions, classes, variables, predicates, and types.
+- Keep each unit at one abstraction level.
+- Prefer direct control flow over clever shortcuts.
+
+Forbidden placeholder names:
+- `data`
+- `temp`
+- `value`
+- `obj`
+- `item`
+- `stuff`
+- `thing`
+
+## Maintainability
+
+Code must have one authoritative implementation per behavior.
+
+Fail when any of these are true:
+- The same multi-step logic appears more than once.
+- The same predicate appears more than once without extraction.
+- Dead code, unreachable branches, unused helpers, or obsolete flags remain.
+- A change to one behavior would require edits in multiple places.
+
+Enforce:
+- Extract duplicated behavior the second time it appears.
+- Delete dead code instead of preserving it "just in case".
+- Centralize shared formatting, validation, mapping, and branching logic.
+
+## Modularity
+
+Each unit must own one responsibility.
+
+Responsibility test:
+- A unit must be describable in one sentence with one primary verb.
+- If that sentence requires `and`, the unit is too broad and must be split.
+
+Fail when any of these are true:
+- Parsing, validation, processing, formatting, output, or IO are mixed in one unit.
+- One class or module coordinates unrelated workflows.
+- A helper exists only to hide a mixed-responsibility block.
+
+Enforce:
+- Separate parsing, validation, processing, formatting, output, and IO into distinct units or layers.
+- Keep orchestration thin and domain logic focused.
+- Assign one reason to change per unit.
+
+## Function Design
+
+Functions and methods must be small, explicit, and side-effect-aware.
+
+Fail when any of these are true:
+- A function cannot be described plainly without mentioning multiple jobs.
+- A function mutates external state, performs IO, or changes shared data without making that effect obvious from its name and role.
+- A helper both decides policy and performs mechanics.
+- A function relies on hidden inputs or writes to hidden outputs.
+
+Enforce:
+- Default to pure helpers; isolate side effects at clear boundaries.
+- Keep parameters and return values explicit.
+- Use focused helpers instead of broad coordinators.
+
+Global length limits:
+- Functions and methods: maximum 20 lines
+- Nesting depth: maximum 3 levels
+
+## Complexity
+
+Control flow must stay linear enough to reason about locally.
+
+Fail when any of these are true:
+- Nesting exceeds 3 levels.
+- A function requires multiple passes to trace normal flow.
+- Boolean logic is dense enough that extracting a named predicate would improve understanding.
+- A long function remains intact after responsibilities and duplication have been identified.
+
+Enforce:
+- Flatten with guard clauses and early returns.
+- Extract named predicates for repeated or dense conditions.
+- Break large functions before performing local polish.
+
+## Consistency
+
+Equivalent problems must use equivalent solutions within the same scope.
+
+Fail when any of these are true:
+- The same kind of work is implemented with multiple patterns in the same file or module.
+- Naming conventions change without a domain reason.
+- Similar validation, mapping, or error-handling flows use different structures.
+- Helper boundaries are inconsistent for equivalent operations.
+
+Enforce:
+- Use one pattern per problem type within a scope.
+- Apply one naming scheme and one decomposition strategy across the file.
+- Normalize similar workflows to the same structure unless an external API forces a difference.
+
+## Transformation Order
+
+Fix violations in this order:
+1. Delete dead code and unreachable paths.
+2. Separate mixed responsibilities.
+3. Extract duplication and repeated predicates.
+4. Reduce nesting and control-flow complexity.
+5. Split oversized or multi-purpose units.
+6. Rename for clarity and consistency.
+7. Recheck language-specific rules.
+
+## Scope Enforcement
+
+For code over 150 lines:
+- Review or refactor the full file unless the user explicitly limits scope.
+- Partition work by logical sections, then normalize across the whole file.
+- Remove cross-section duplication.
+- Do not leave one section on a different naming or structural pattern from the rest.
+
+## Language-Specific Rules
+
+### Python
+
+Fail when any of these are true:
+- Nesting exceeds 3 levels.
+- A comprehension hides branching or multi-step transformation.
+- Dense one-liners reduce clarity.
+
+Enforce:
+- Prefer explicit control flow once a comprehension stops being immediately readable.
+- Keep data flow obvious from names and statement order.
+
+### Java
+
+Fail when any of these are true:
+- A class exceeds 300 lines.
+- A method exceeds 20 lines.
+- Method visibility is implicit or omitted.
+- Service, utility, and model responsibilities are mixed.
+
+Enforce:
+- Use small private helpers.
+- Keep classes narrowly scoped.
+- Keep validation and formatting outside core business methods.
+
+### TypeScript
+
+Fail when any of these are true:
+- `any` is used.
+- Parameter types are implicit.
+- Return types are implicit.
+- Reused object shapes remain anonymous.
+
+Enforce:
+- Use explicit function signatures.
+- Prefer named interfaces or type aliases for reused shapes.
+- Keep transformation logic in typed helpers.
+
+## Determinism
+
+For the same input, produce the same:
+- violation ordering
+- extraction strategy
+- naming pattern
+- output structure
+
+Do not vary the result for style, novelty, or personal preference.

package/skills/senior-code-reviewer/SKILL.md

@@ -0,0 +1,80 @@
+---
+name: senior-code-reviewer
+description: Senior-level code review for JavaScript, TypeScript, and Python with balanced strictness. Use for pull request review or local snippet review when the goal is to identify the highest-risk issues, prioritize architectural and systemic problems, and give concise, judgment-based feedback instead of mechanical rule enforcement.
+---
+
+# Senior Code Reviewer
+
+Use this skill for JavaScript, TypeScript, and Python review when impact matters more than completeness.
+
+## Operating Directive
+
+Think like a senior engineer reviewing a pull request.
+
+Prioritize judgment over coverage.
+
+Prefer depth over breadth.
+
+Prefer impact over completeness.
+
+Prefer reasoning over rules.
+
+Do not behave like a clean-code enforcer.
+
+Do not rewrite full code.
+
+Do not hallucinate problems.
+
+## Review Scope
+
+Prefer full-file or module context when available.
+
+If only a snippet is provided, limit conclusions to visible code and avoid assumptions about missing architecture, intent, or surrounding systems.
+
+## Severity Model
+
+- Critical: correctness, security, scalability, or major design flaw
+- Warning: maintainability, coupling, or unclear structure
+- Suggestion: optional improvement
+
+## Review Behavior
+
+- Report at most 3 to 5 issues total unless there is a critical failure.
+- Always list the highest-risk issues first.
+- Architectural or systemic issues must appear before local issues.
+- If one issue dominates the risk, focus on it instead of listing smaller issues.
+- Classify issues as Critical when they affect correctness, error visibility, or observable system behavior. Treat silent failures, ambiguous return values, and loss of error information as Critical. Do not default to lower severity when the risk is high.
+- Ignore style unless it affects correctness or maintainability.
+- Do not flag trivial issues unless they contribute to real risk.
+- Consider architecture and boundaries, data flow clarity, coupling and cohesion, testability, error handling strategy, performance risks, and security risks.
+- Each issue must reference the code, explain why it is a problem, describe the risk it creates, and suggest a direction without rewriting the code.
+- If context is incomplete, limit conclusions to what can be confidently inferred.
+
+## Output Format
+
+Omit any empty severity section instead of rendering it with no items.
+
+```text
+Critical
+- [code reference] Why: ... Risk: ... Direction: ...
+
+Warnings
+- [code reference] Why: ... Risk: ... Direction: ...
+
+Suggestions
+- [code reference] Why: ... Risk: ... Direction: ...
+
+Structural Risk
+- ...
+
+Summary
+- ...
+```
+
+## Structural Risk Requirement
+
+Identify the single biggest design issue and explain why it matters at scale.
+
+## Summary Requirement
+
+End with a 2 to 3 sentence summary that states the most important takeaway.

package/skills/senior-code-reviewer/agents/openai.yaml

@@ -0,0 +1,3 @@
+name: senior-code-reviewer
+description: High-signal senior-level code review focused on risk, architecture, and prioritization
+entrypoint: SKILL.md

package/src/cli.js

@@ -0,0 +1,103 @@
+const {
+  installSkills,
+  listSupportedAssistants,
+  printHelp,
+} = require("./installers");
+
+function parseArgs(argv) {
+  let command;
+  const rest = [];
+  const options = {
+    ai: "all",
+    cwd: process.cwd(),
+    global: false,
+    force: false,
+    help: false,
+  };
+
+  for (const arg of argv) {
+    if (!command && !arg.startsWith("-")) {
+      command = arg;
+      continue;
+    }
+
+    rest.push(arg);
+  }
+
+  for (let index = 0; index < rest.length; index += 1) {
+    const arg = rest[index];
+
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+      continue;
+    }
+
+    if (arg === "--global" || arg === "-g") {
+      options.global = true;
+      continue;
+    }
+
+    if (arg === "--force" || arg === "-f") {
+      options.force = true;
+      continue;
+    }
+
+    if (arg === "--ai" || arg === "-a") {
+      const value = rest[index + 1];
+      if (!value) {
+        throw new Error("Missing value for --ai");
+      }
+      options.ai = value;
+      index += 1;
+      continue;
+    }
+
+    if (arg === "--dir" || arg === "-d") {
+      const value = rest[index + 1];
+      if (!value) {
+        throw new Error("Missing value for --dir");
+      }
+      options.cwd = value;
+      index += 1;
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return {
+    command,
+    options,
+  };
+}
+
+async function main() {
+  try {
+    const { command, options } = parseArgs(process.argv.slice(2));
+
+    if (!command || options.help) {
+      printHelp();
+      return;
+    }
+
+    if (command !== "init") {
+      throw new Error(
+        `Unsupported command "${command}". Supported commands: init`
+      );
+    }
+
+    const supportedAssistants = listSupportedAssistants();
+    await installSkills({
+      ai: options.ai,
+      cwd: options.cwd,
+      globalInstall: options.global,
+      force: options.force,
+      supportedAssistants,
+    });
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exitCode = 1;
+  }
+}
+
+main();

package/src/installers.js

@@ -0,0 +1,366 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const REPO_ROOT = path.resolve(__dirname, "..");
+const SKILLS_DIR = path.join(REPO_ROOT, "skills");
+const SKILL_MANIFEST_PATH = path.join(REPO_ROOT, "skill.json");
+
+function readManifest() {
+  return JSON.parse(fs.readFileSync(SKILL_MANIFEST_PATH, "utf8"));
+}
+
+function listSkillDirectories() {
+  return fs
+    .readdirSync(SKILLS_DIR, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .filter((entry) =>
+      fs.existsSync(path.join(SKILLS_DIR, entry.name, "SKILL.md"))
+    )
+    .map((entry) => entry.name)
+    .sort();
+}
+
+function listSupportedAssistants() {
+  return readManifest().assistants;
+}
+
+function parseAiTargets(aiValue, supportedAssistants) {
+  if (!aiValue || aiValue === "all") {
+    return supportedAssistants;
+  }
+
+  const targets = aiValue
+    .split(",")
+    .map((value) => value.trim().toLowerCase())
+    .filter(Boolean);
+
+  const invalidTargets = targets.filter(
+    (target) => !supportedAssistants.includes(target)
+  );
+
+  if (invalidTargets.length > 0) {
+    throw new Error(
+      `Unsupported assistant(s): ${invalidTargets.join(
+        ", "
+      )}. Supported assistants: ${supportedAssistants.join(", ")}`
+    );
+  }
+
+  return [...new Set(targets)];
+}
+
+function ensureDirectory(targetDirectory) {
+  fs.mkdirSync(targetDirectory, { recursive: true });
+}
+
+function copyDirectory(sourceDirectory, targetDirectory, force, excludedNames = []) {
+  ensureDirectory(targetDirectory);
+
+  for (const entry of fs.readdirSync(sourceDirectory, { withFileTypes: true })) {
+    if (entry.name === ".DS_Store" || excludedNames.includes(entry.name)) {
+      continue;
+    }
+
+    const sourcePath = path.join(sourceDirectory, entry.name);
+    const targetPath = path.join(targetDirectory, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDirectory(sourcePath, targetPath, force, excludedNames);
+      continue;
+    }
+
+    if (!force && fs.existsSync(targetPath)) {
+      throw new Error(
+        `Refusing to overwrite existing file without --force: ${targetPath}`
+      );
+    }
+
+    fs.copyFileSync(sourcePath, targetPath);
+  }
+}
+
+function writeFile(targetPath, content, force) {
+  ensureDirectory(path.dirname(targetPath));
+
+  if (!force && fs.existsSync(targetPath)) {
+    throw new Error(
+      `Refusing to overwrite existing file without --force: ${targetPath}`
+    );
+  }
+
+  fs.writeFileSync(targetPath, content, "utf8");
+}
+
+function pathExists(targetPath) {
+  return fs.existsSync(targetPath);
+}
+
+function stripFrontMatter(markdownContent) {
+  if (!markdownContent.startsWith("---")) {
+    return markdownContent.trim();
+  }
+
+  const match = markdownContent.match(/^---\n[\s\S]*?\n---\n?/);
+  if (!match) {
+    return markdownContent.trim();
+  }
+
+  return markdownContent.slice(match[0].length).trim();
+}
+
+function readSkill(skillName) {
+  const skillDirectory = path.join(SKILLS_DIR, skillName);
+  const skillPath = path.join(skillDirectory, "SKILL.md");
+  const skillContent = fs.readFileSync(skillPath, "utf8");
+
+  const descriptionMatch = skillContent.match(/description:\s*(.+)/);
+
+  return {
+    name: skillName,
+    directory: skillDirectory,
+    description: descriptionMatch ? descriptionMatch[1].trim() : skillName,
+    content: skillContent,
+    body: stripFrontMatter(skillContent),
+  };
+}
+
+function readRelativeFile(skillName, relativePath) {
+  return fs.readFileSync(path.join(SKILLS_DIR, skillName, relativePath), "utf8").trim();
+}
+
+function resolveAssistantOverridePath(skillName, assistant, fileName) {
+  return path.join(SKILLS_DIR, skillName, "overrides", assistant, fileName);
+}
+
+function readAssistantOverride(skillName, assistant, fileName) {
+  const overridePath = resolveAssistantOverridePath(skillName, assistant, fileName);
+
+  if (!pathExists(overridePath)) {
+    return null;
+  }
+
+  return fs.readFileSync(overridePath, "utf8");
+}
+
+function buildCopilotPromptBody(skill) {
+  if (skill.name !== "clean-code-enforcer") {
+    return skill.body;
+  }
+
+  const rulesContent = readRelativeFile(skill.name, "references/rules.md");
+  const normalizedBody = skill.body.replace(
+    "Load [references/rules.md](references/rules.md) before producing output. That file is the source of truth for enforcement criteria and failure conditions.",
+    "Use the inlined `references/rules.md` content below as the source of truth for enforcement criteria and failure conditions."
+  );
+
+  return `${normalizedBody}
+
+## Inlined Reference
+
+The following content is inlined for GitHub Copilot because prompt files do not load repository-relative markdown dependencies automatically.
+
+### references/rules.md
+
+\`\`\`md
+${rulesContent}
+\`\`\`
+`;
+}
+
+function resolveCodexTarget(globalInstall, cwd) {
+  return globalInstall
+    ? path.join(os.homedir(), ".codex", "skills")
+    : path.join(cwd, ".codex", "skills");
+}
+
+function resolveClaudeTarget(globalInstall, cwd) {
+  return globalInstall
+    ? path.join(os.homedir(), ".claude", "skills")
+    : path.join(cwd, ".claude", "skills");
+}
+
+function resolveCopilotTarget(globalInstall, cwd) {
+  if (globalInstall) {
+    throw new Error(
+      "GitHub Copilot installation is project-scoped in this CLI. Remove --global or install Codex and Claude separately."
+    );
+  }
+
+  return path.join(cwd, ".github");
+}
+
+function buildCopilotPrompt(skill) {
+  const explicitPrompt = readAssistantOverride(
+    skill.name,
+    "githubcopilot",
+    "prompt.md"
+  );
+
+  if (explicitPrompt) {
+    return explicitPrompt;
+  }
+
+  return `---
+agent: 'agent'
+description: '${skill.description.replace(/'/g, "''")}'
+---
+
+${buildCopilotPromptBody(skill)}
+`;
+}
+
+function buildCopilotInstructions(skillNames) {
+  const instructionOverrides = skillNames
+    .map((skillName) =>
+      readAssistantOverride(skillName, "githubcopilot", "instructions.md")
+    )
+    .filter(Boolean)
+    .join("\n\n");
+
+  const slashCommands = skillNames
+    .map((skillName) => `- \`/${skillName}\``)
+    .join("\n");
+
+  return `# Code Review Pro Instructions
+
+Use the installed prompts for task-specific behavior:
+
+${slashCommands}
+
+Default operating rules:
+
+- Separate evaluation from transformation.
+- Prefer high-signal review over broad, noisy checklists.
+- When the user asks for critique, use the reviewer behavior.
+- When the user asks for refactoring or rewriting, use the clean-code behavior.
+
+${instructionOverrides ? `Skill-specific notes:\n\n${instructionOverrides}\n` : ""}`;
+}
+
+function installNativeSkillDirectory(skillName, assistant, targetRoot, force) {
+  const overrideDirectory = resolveAssistantOverridePath(skillName, assistant, "skill");
+  const targetDirectory = path.join(targetRoot, skillName);
+
+  if (pathExists(overrideDirectory)) {
+    copyDirectory(overrideDirectory, targetDirectory, force);
+    return;
+  }
+
+  copyDirectory(path.join(SKILLS_DIR, skillName), targetDirectory, force, ["overrides"]);
+}
+
+function installForCodex(skillNames, cwd, globalInstall, force) {
+  const targetRoot = resolveCodexTarget(globalInstall, cwd);
+  ensureDirectory(targetRoot);
+
+  for (const skillName of skillNames) {
+    installNativeSkillDirectory(skillName, "codex", targetRoot, force);
+  }
+
+  return targetRoot;
+}
+
+function installForClaude(skillNames, cwd, globalInstall, force) {
+  const targetRoot = resolveClaudeTarget(globalInstall, cwd);
+  ensureDirectory(targetRoot);
+
+  for (const skillName of skillNames) {
+    installNativeSkillDirectory(skillName, "claude", targetRoot, force);
+  }
+
+  return targetRoot;
+}
+
+function installForGitHubCopilot(skillNames, cwd, globalInstall, force) {
+  const targetRoot = resolveCopilotTarget(globalInstall, cwd);
+  const promptsDirectory = path.join(targetRoot, "prompts");
+
+  ensureDirectory(promptsDirectory);
+
+  for (const skillName of skillNames) {
+    const skill = readSkill(skillName);
+    writeFile(
+      path.join(promptsDirectory, `${skillName}.prompt.md`),
+      buildCopilotPrompt(skill),
+      force
+    );
+  }
+
+  writeFile(
+    path.join(targetRoot, "copilot-instructions.md"),
+    buildCopilotInstructions(skillNames),
+    force
+  );
+
+  return targetRoot;
+}
+
+async function installSkills({
+  ai,
+  cwd,
+  globalInstall,
+  force,
+  supportedAssistants,
+}) {
+  const targets = parseAiTargets(ai, supportedAssistants);
+  const skillNames = listSkillDirectories();
+  const results = [];
+
+  for (const target of targets) {
+    if (target === "codex") {
+      results.push({
+        assistant: target,
+        path: installForCodex(skillNames, cwd, globalInstall, force),
+      });
+      continue;
+    }
+
+    if (target === "claude") {
+      results.push({
+        assistant: target,
+        path: installForClaude(skillNames, cwd, globalInstall, force),
+      });
+      continue;
+    }
+
+    if (target === "githubcopilot") {
+      results.push({
+        assistant: target,
+        path: installForGitHubCopilot(skillNames, cwd, globalInstall, force),
+      });
+      continue;
+    }
+  }
+
+  for (const result of results) {
+    console.log(`Installed ${readManifest().name} for ${result.assistant}: ${result.path}`);
+  }
+}
+
+function printHelp() {
+  const assistants = listSupportedAssistants().join(", ");
+
+  console.log(`codepro init [options]
+
+Install code review skills for supported AI assistants.
+
+Options:
+  -a, --ai <targets>    Assistant target(s): ${assistants}, or all
+  -d, --dir <path>      Project directory for project-scoped installs
+  -f, --force           Overwrite existing generated files
+  -g, --global          Install to home-directory targets when supported
+  -h, --help            Show this help message
+
+Examples:
+  codepro init --ai codex --global
+  codepro init --ai claude,githubcopilot
+  codepro init --ai all --dir /tmp/demo
+`);
+}
+
+module.exports = {
+  installSkills,
+  listSupportedAssistants,
+  printHelp,
+};