c2c

Category: Tools & Productivity | Uploader: ast-ashulga | Downloads: 0 | Version: v1.0（Latest）
Migrate Claude Code .claude/ configurations to Cursor IDE — skills → .cursor/skills/, agents → .cursor/agents/, rules → .cursor/rules/*.mdc, with semantic fidelity per source type
Changelog: Source: GitHub https://github.com/ast-ashulga/as.migrate.c2c
Directory Structure

Current level: tree/main/.claude/skills/c2c/
📄 SKILL.md 20.5 KB
SKILL.md

---
name: c2c
description: Migrate Claude Code .claude/ configurations to Cursor IDE — skills → .cursor/skills/, agents → .cursor/agents/, rules → .cursor/rules/*.mdc, with semantic fidelity per source type
---

# c2c — Claude-to-Cursor Semantic Migration

You are a semantic migration specialist. When invoked, you read a Claude Code `.claude/` directory, understand the intent behind each configuration file, and generate the correct Cursor-native output for each source type. Each Claude Code concept maps to a different Cursor mechanism — not everything goes to `.mdc` rules.

**Output targets by source type:**

| Claude Code source | Cursor output | Location |
|--------------------|---------------|----------|
| `CLAUDE.md` inline content | Always Apply rule | `.cursor/rules/project-instructions.mdc` |
| `CLAUDE.md` inline content *(if no `AGENTS.md` at dest root)* | Cross-tool project instructions | `AGENTS.md` (project root) |
| `@`-imported framework doc | Always Apply rule | `.cursor/rules/framework-{name}.mdc` |
| `MODE_*.md` behavioral mode | Agent Requested rule | `.cursor/rules/mode-{name}.mdc` |
| `commands/**/*.md` slash command | Skill (explicit-only) | `.cursor/skills/{name}/SKILL.md` |
| `agents/*.md` agent persona | Custom subagent | `.cursor/agents/{name}.md` |
| `skills/*/SKILL.md` skill bundle | Cursor skill | `.cursor/skills/{name}/SKILL.md` |

This is not a copy-paste job. You read, comprehend, and rewrite — adapting Claude Code concepts into Cursor-native structures while preserving the underlying knowledge and guidance.

## Arguments

Parse these from the user's invocation (accept both flag syntax and natural language):

| Argument | Default | Meaning |
|----------|---------|---------|
| `--source <path>` | `.claude/` in current project, or `./CLAUDE.md` sibling | Source directory to migrate |
| `--output <path>` | `.cursor/` | Root output directory |
| `--dry-run` | false | Show what would be generated without writing |
| `--global` | false | Also scan `~/.claude/` (global user config) |
| `--skip-agents-md` | false | Skip generating `AGENTS.md` even when destination lacks one |
| `--skip-native-skills` | false | Skip copying skills already in `.claude/skills/` (natively readable by Cursor without migration) |

Derived output subdirectories: `{output}/rules/`, `{output}/skills/`, `{output}/agents/`.

---

## Phase 1: Discovery

Use Claude Code's tools to find all source files.

**Step 1 — Locate CLAUDE.md**

Use Read to check:
- `{source}/CLAUDE.md`
- `./CLAUDE.md` (project root, sibling to `.claude/`)

Read it. Separate the `@filename` import lines from the inline content.

**Step 2 — Resolve @-imports**

For each `@filename` line in CLAUDE.md:
- Read the file (relative to CLAUDE.md's directory)
- Classify by filename pattern:
  - `MCP_*` or `mcp-*` → **skip** (not portable — MCP configs are environment-specific)
  - `MODE_*` or `mode-*` → behavioral mode
  - Anything else → framework/project guideline doc

**Step 3 — Scan source directories**

Use Glob to find:
- `{source}/commands/**/*.md` → slash commands
- `{source}/agents/*.md` → agent personas
- `{source}/skills/*/SKILL.md` → skill bundles (note sibling dirs as bundled assets)
- `{source}/MODE_*.md` and `{source}/mode-*.md` → standalone modes (exclude duplicates already found via @-imports)

**Step 4 — Check destination for existing AGENTS.md**

Derive the destination project root from `{output}`: strip the trailing `.cursor/` component to get the parent directory (e.g., if `--output /project/.cursor/`, the root is `/project/`).

Use Read to check: `{dest-root}/AGENTS.md`

Record the result as `agents_md_exists: true | false`. This controls whether AGENTS.md generation runs in Phase 2.

**Step 5 — Detect non-portable items**

Check for existence and record as skipped:
- `{source}/settings.json` — Claude Code settings
- `{source}/settings.local.json` — project permissions
- `{source}/config.json` — MCP server config
- `{source}/hooks/*.sh` — lifecycle hook scripts
- `{source}/MCP_*.md` — MCP server docs

**Step 6 — Cross-tool compatibility check**

Cursor natively reads `.claude/skills/` as a read-only source. If the source is the same project's `.claude/` directory (i.e., not a remote source being imported), note in the report that skills in `.claude/skills/` are already visible to Cursor without migration. Still migrate them to `.cursor/skills/` unless `--skip-native-skills` is passed.

---

## Phase 2: Semantic Migration

For each discovered item, read its content, understand its intent, and generate the correct Cursor-native output.

---

### CLAUDE.md inline content → `.cursor/rules/project-instructions.mdc`

```yaml
description: ""
alwaysApply: true
globs: ""
```

Read the inline content (lines that are not `@`-imports). Understand what project-level instructions it establishes: coding conventions, architectural decisions, team standards, what to always/never do.

Generate a `project-instructions.mdc` that captures these as universal AI assistant instructions. Write them as guidance that any capable AI coding assistant can follow — not tied to Claude Code's tools or APIs.

**Strip:** references to specific Claude Code tools (TodoWrite, Bash, Glob, etc.), MCP server instructions, slash command syntax, hook scripts.

**Preserve:** architectural constraints, coding standards, project conventions, team rules, rationale behind decisions.

**Example:**

Source `CLAUDE.md` inline content:
```
- Always write tests for new functions
- Never commit secrets or API keys
- Use TodoWrite to track multi-step tasks
- Run tests before marking tasks complete
```

Generated `project-instructions.mdc` body:
```
- Always write tests for new functions
- Never commit secrets or API keys
- Track multi-step tasks explicitly and verify completion
- Run tests before considering any change done
```

---

### CLAUDE.md inline content → `AGENTS.md` *(required)*

**Required**: Always generate when CLAUDE.md exists — unless `agents_md_exists = true` (never overwrite an existing file) or `--skip-agents-md` was explicitly passed. This is a default-on step: the question is not whether to do it, but whether something blocks it.

`AGENTS.md` is the cross-tool portable AI instruction file at the project root — readable by Cursor, Codex, and any other AI coding assistant that follows the emerging `AGENTS.md` convention. Creating it bridges the gap between Claude Code's project instructions and the broader AI tooling ecosystem.

**Output location**: `{dest-root}/AGENTS.md` — at the project root (same level as `.cursor/`), not inside `.cursor/`.

**Format**: Plain Markdown, no YAML frontmatter. `AGENTS.md` is a cross-tool format; frontmatter would break tools that don't understand it.

Apply the same sanitization rules as `project-instructions.mdc`:

**Strip:** references to Claude Code-specific tools (TodoWrite, Bash, Glob, Read, etc.), MCP server instructions, slash command syntax, hook scripts, `@`-import lines.

**Preserve:** architectural constraints, coding standards, project conventions, team rules, rationale behind decisions — everything a generic AI coding assistant can act on.

**Opening line**: Begin the file with `# Project Instructions` (or preserve the existing heading if CLAUDE.md has one) so the purpose is clear to both humans and AI tools.

**Example:**

Source CLAUDE.md:
```
- Always write tests for new functions
- Use TodoWrite to track multi-step tasks
- Never commit secrets or API keys
```

Generated `AGENTS.md`:
```markdown
# Project Instructions

- Always write tests for new functions
- Track multi-step tasks explicitly and verify completion
- Never commit secrets or API keys
```

---

### @-imported framework docs → `.cursor/rules/framework-{name}.mdc`

```yaml
description: ""
alwaysApply: true
globs: ""
```

Framework docs are project-wide reference files: coding standards, architectural patterns, workflow rules, engineering principles. They are always-apply because they were always-loaded via CLAUDE.md.

Read the full file. Identify the core guidance: what coding practices does it establish? What architectural decisions? What should an AI assistant know to work well in this project?

**Strip:** MCP server coordination sections, tool allowlists, slash command syntax (`/sc:*`), Claude Code session lifecycle commands, any section titled "Tool Coordination", "MCP Integration", or "Available Tools".

**Preserve:** engineering principles, coding conventions, domain knowledge, architectural constraints, examples, code snippets, decision rationale.

**Filename:** strip extension, kebab-case → e.g., `RULES.md` → `framework-rules.mdc`, `PRINCIPLES.md` → `framework-principles.mdc`

---

### Behavioral modes (MODE_*.md) → `.cursor/rules/mode-{name}.mdc`

```yaml
description: "{extracted purpose, max 200 chars}"
alwaysApply: false
globs: ""
```

Behavioral modes define how an AI assistant shifts its reasoning style in specific contexts: brainstorming, deep research, token efficiency, orchestration, etc. In Cursor, these become Agent Requested rules — the agent loads them when the context matches.

Read the mode file. Understand: what is this mode's purpose? When does it activate? How does it change the AI's behavior?

**Strip:** MCP server tool selection tables, specific MCP tool names (Sequential MCP, Context7 MCP, etc.), slash command syntax (`/sc:*`), session lifecycle commands, "Tool Selection Matrix" sections.

**Preserve:** the behavioral mindset, cognitive approach, output characteristics, examples of adapted behavior, activation heuristics reframed as contextual cues.

**Description field:** extract from `**Purpose**:` line if present, otherwise summarize the mode's role in one sentence (≤200 chars).

**Filename:** strip `MODE_` or `mode-` prefix, kebab-case → `MODE_Brainstorming.md` → `mode-brainstorming.mdc`

---

### Commands (commands/**/*.md) → `.cursor/skills/{name}/SKILL.md`

```yaml
name: {command-name}
description: "{from frontmatter description, max 1024 chars}"
disable-model-invocation: true
```

Claude Code commands are explicit slash commands that trigger specific workflows. In Cursor, they become **skills with `disable-model-invocation: true`** — preserving the "user must explicitly invoke" contract. The user invokes them as `/skill-name` in Cursor's agent chat.

Read the command file. Parse the YAML frontmatter for `name` and `description`. Understand: what does this command do? What's the workflow it orchestrates? What is the output?

Write the SKILL.md body as: "When invoked, [procedure here]..." — concrete steps the agent should follow, what to look for, what to produce. Focus on the workflow, the thinking, the deliverable.

**Strip:** slash command invocation syntax, MCP server coordination sections, persona activation instructions, TodoWrite/TaskCreate calls.

**Output location:** `.cursor/skills/{name}/SKILL.md` (create the `{name}/` subdirectory)

**Filename derivation:** frontmatter `name` → kebab-case → directory name

---

### Agent personas (agents/*.md) → `.cursor/agents/{name}.md`

```yaml
name: {agent-name}
description: "{from frontmatter description, max 1024 chars}"
model: inherit
readonly: false
```

Claude Code agents are specialist personas with defined expertise, focus areas, and behavioral mindsets. In Cursor, these map directly to **custom subagents** (`.cursor/agents/*.md`) — the structural equivalent in both ecosystems.

Read the agent file. Parse frontmatter fields (`name`, `description`, `model`, `allowed-tools`).

**Frontmatter translation:**
- `name` → `name` (preserve)
- `description` → `description` (preserve or adapt if Claude-specific)
- `model` → `model: inherit` (Claude model IDs are not valid in Cursor; user must configure)
- `allowed-tools` → omit (no Cursor equivalent; note in warnings)
- `context: fork` → omit; add a warning suggesting the user create a `.cursor/agents/` entry if an isolated execution context is needed

Write the agent body as a Cursor subagent definition. Keep the expertise framing, the approach to problems, and the behavioral instructions. Make it actionable for Cursor's agent engine.

**Strip:** Claude-agent-specific coordination patterns, MCP integration sections, tool allowlists, spawn/delegation syntax specific to Claude Code.

**Output location:** `.cursor/agents/{name}.md`

---

### Skills (skills/*/SKILL.md) → `.cursor/skills/{name}/SKILL.md`

```yaml
name: {skill-name}
description: "{from frontmatter description}"
```

Claude Code skills and Cursor skills share the same open standard (`agentskills.io`). The `SKILL.md` format is nearly identical — this is the highest-fidelity migration path.

Read the SKILL.md. Parse all frontmatter fields.

**Frontmatter translation:**

| Claude Code field | Cursor equivalent | Action |
|---|---|---|
| `name` | `name` | Preserve |
| `description` | `description` | Preserve |
| `disable-model-invocation` | `disable-model-invocation` | Preserve (same behavior) |
| `allowed-tools` | — | Omit, note in warnings |
| `user-invocable` | — | Omit (not documented in Cursor) |
| `context: fork` | — | Omit; note that Cursor uses `.cursor/agents/` for isolated contexts |
| `argument-hint` | — | Omit (not documented in Cursor) |
| `model` | — | Omit (model override not documented in Cursor skills) |
| `effort` | — | Omit |
| `paths` | — | Omit (not documented in Cursor) |
| `version`, `license`, `metadata` | `metadata` | Consolidate into `metadata` block |

**Body:** preserve as-is. Skills contain real domain knowledge, patterns, and procedures — this content is directly valuable in Cursor. Keep all code examples, best practices, constraints, and reference patterns.

**Strip only:** `allowed-tools` references in the body text if any, Claude SDK-specific API calls, references to `${CLAUDE_SKILL_DIR}` or `${CLAUDE_SESSION_ID}` (replace with generic notes or remove).

**Bundled subfolders (required):** Every subdirectory alongside `SKILL.md` MUST be copied — omitting them produces a broken skill bundle. Cursor skills share the same `scripts/`, `references/`, `assets/` layout as Claude Code via the `agentskills.io` open standard; arbitrary subdirectory names are also supported. Steps:

1. Use Glob to find all files under `{source}/skills/{name}/` excluding `SKILL.md` itself.
2. For each file, copy it to `{output}/skills/{name}/{relative-path}` using Write (preserving the subfolder structure). Use the fully resolved `{output}` path — never a hardcoded relative `.cursor/` — so this works correctly when source and destination are in different project directories.
3. **Non-standard subfolder names** (e.g., `examples/`, `docs/`) — copy as-is.
4. List each copied subfolder in the migration report. If subfolders exist but cannot be read, report as an error — do not silently skip.

**`${CLAUDE_SKILL_DIR}` and `${CLAUDE_SESSION_ID}` in body:** These variables are Claude Code-specific and are **not documented in Cursor**. In the SKILL.md body, replace every occurrence of `${CLAUDE_SKILL_DIR}` with `(skill directory)` and `${CLAUDE_SESSION_ID}` with `(session id)`. Add a warning to the report for each skill where these substitutions were made.

**Script portability:** Files in `scripts/` are copied as-is. Shell and Python scripts with hardcoded environment paths may need manual adjustment in the target environment. Note this in warnings.

**Output location:** `.cursor/skills/{name}/SKILL.md` (create the `{name}/` subdirectory)

---

## Phase 3: Write Output

For each generated item:

1. Determine the output path per the table at the top of this skill.
2. Compose the file content.

**For `.cursor/rules/*.mdc` files:**

```
---
description: "description text here"
globs: ""
alwaysApply: true
---

[body content]
```

Always emit all three frontmatter fields. `globs` is always `""`. `alwaysApply` is `true` for `project-instructions.mdc` and `framework-*.mdc`; `false` for `mode-*.mdc`. Wrap `description` in double quotes; escape any `"` inside as `\"`.

**For `.cursor/skills/{name}/SKILL.md` files:**

```
---
name: skill-name
description: "description text here"
[other translated fields]
---

[body content]
```

Create the parent directory `{name}/` before writing.

**For skill subdirectory files** (`{output}/skills/{name}/scripts/*`, `references/*`, `assets/*`, or any other subfolder): write each file at its mirrored path under `{output}/skills/{name}/` using the fully resolved `{output}` path. Never use a hardcoded relative `.cursor/` prefix — when source and destination are in different directories, relative paths will resolve to the wrong location. Read the source file and write it verbatim — do not transform content of bundled assets. If a file is binary (image, compiled artifact), note it in the report as "binary — verify compatibility" but still copy it.

**For `AGENTS.md`** (when generated):

Write to `{dest-root}/AGENTS.md`. No YAML frontmatter. Plain Markdown only.

**For `.cursor/agents/{name}.md` files:**

```
---
name: agent-name
description: "description text here"
model: inherit
readonly: false
---

[body content]
```

If `--dry-run`: print each file's target path, type, and a preview of the first 3 lines of generated content. Do not write files.

Otherwise: use Write to create each file at the resolved path.

---

## Phase 4: Migration Report

After completing all writes (or the dry-run preview), print:

```
## c2c Migration Report

Source: {source path}
Output: {output path}

### Converted ({n} items)
| Output file | Source | Type | Apply |
|-------------|--------|------|-------|
| rules/project-instructions.mdc | CLAUDE.md inline | claude-md | always |
| AGENTS.md | CLAUDE.md inline | agents-md | cross-tool |
| rules/framework-rules.mdc | RULES.md | framework | always |
| rules/mode-brainstorming.mdc | MODE_Brainstorming.md | mode | agent-requested |
| skills/commit/SKILL.md | commands/commit.md | command→skill | explicit-only |
| agents/backend-architect.md | agents/backend-architect.md | agent | subagent |
| skills/nova-act/SKILL.md | skills/nova-act/SKILL.md | skill | auto+explicit |
| skills/generate-level/SKILL.md | skills/generate-level/SKILL.md | skill | auto+explicit |
| skills/generate-level/examples/ (5 files) | skills/generate-level/examples/ | skill-assets | — |
| skills/generate-level/scripts/ (2 files) | skills/generate-level/scripts/ | skill-scripts | — |

### Skipped ({n} items)
| Item | Reason |
|------|--------|
| MCP_Aws.md | MCP server docs — environment-specific, not portable |
| settings.json | Claude Code runtime settings — not portable |
| hooks/pre-commit.sh | Lifecycle hooks — must be re-expressed in .cursor/hooks.json manually |

### Warnings
- skills/generate-level: ${CLAUDE_SKILL_DIR} replaced with (skill directory) — verify Cursor supports this variable
- skills/generate-level: scripts/verify_level.py, scripts/preview_level.py copied — may need path adjustments for target environment
- skills/generate-level: examples/ is a non-standard subfolder — copied as-is; verify Cursor loads it
- agents/backend-architect: allowed-tools not migrated — no Cursor equivalent
- agents/backend-architect: model ID replaced with 'inherit' — configure in Cursor settings
- skills already in .claude/skills/ are natively readable by Cursor without migration
```

---

## Edge Cases

- **Missing CLAUDE.md**: Skip `project-instructions.mdc` and `AGENTS.md` generation, continue with other types.
- **Existing `AGENTS.md` at destination**: Never overwrite. Skip generation and add a note to the report: "AGENTS.md already exists at destination — skipped to avoid overwriting existing cross-tool instructions."
- **`--output` is the project root itself** (not a `.cursor/` subdirectory): Derive dest-root as the output path directly, not by stripping a `.cursor/` component.
- **Missing imported file** (`@foo.md` but `foo.md` not found): Skip with warning "Could not resolve @foo.md".
- **Command/agent without frontmatter**: Derive name from filename (kebab-case), use empty description.
- **Empty body after migration** (everything was Claude-specific): Write a minimal file with a one-line note that the source was tool-specific and had no portable content.
- **Name collision** (two sources produce the same output path): Append `-2`, `-3` to the second and subsequent items; note in report.
- **`--global` flag**: Repeat discovery for `~/.claude/`. Project-level items take precedence over global items with the same name.
- **Skill with `context: fork`**: Omit the field; add a warning suggesting the user create a `.cursor/agents/` entry if isolated execution is needed.
- **Cross-tool skills** (skill already works natively): Note in report; still generate `.cursor/skills/` copy for explicitness unless content is identical and has no Claude-specific content to strip.
Comments 0
Latest | Hot
Please login before commenting.
Loading comments...
c2c

Directory Structure

SKILL.md

Report

Notice
