What makes 编程语言迁移 notable?

1.1K downloads. Trust evidence available

How should 编程语言迁移 be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

编程语言迁移

AI-driven full-project language migration skill. Use this skill whenever the user wants to port, translate, or rewrite a codebase from one programming langua... Skill: 编程语言迁移 Owner: suifei Summary: AI-driven full-project language migration skill. Use this skill whenever the user wants to port, translate, or rewrite a codebase from one programming langua... Tags: latest:1.3.1 Version history: v1.3.1 | 2026-05-18T02:32:46.759Z | user v1.3 — Bug Triage Protocol + Real-World Validation Every P5 test failure now goes through a mandatory 3-step triage before any fix is attempted.

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.1k

Updated

Oct 11, 2026

Version

1.3.1

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.1K downloads reported by the source. Last updated 10/11/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 11, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 11, 2026
Adoption signal: 1.1K downloadsadoption · observed Oct 11, 2026
Latest release: 1.3.1release · observed May 18, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s17cwv8cyfy64wkqte2x67hesn86s5rq:lang-migration

Setup complexity is LOW. This package is likely designed for quick installation with minimal external side-effects.
Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-suifei-lang-migration/snapshot"

Documentation

CLAWHUB

147,017 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: lang-migration
description: >
  AI-driven full-project language migration skill. Use this skill whenever the user wants to
  port, translate, or rewrite a codebase from one programming language to another — including
  Python→Rust, Python→Go, Python→C, Python→C++, Python→Zig, Python→Bun/TS, or any other pair.
  Also trigger when user mentions "精确复刻", "语言迁移", "port project", "translate codebase",
  "1:1 rewrite", or "language conversion". This skill enforces structural equivalence first,
  full asset coverage (no file skipped), persistent YAML state across sessions, and a strict
  no-mock verification policy with human-gated blocking.
license: MIT
---

## Author & Attribution

**Original Author**: flynn  
**Contact**: https://github.com/suifei/lang-migration-skill  
**Role**: Architect, Developer, Documenter  
**Expertise**: Software engineering, programming languages, AI workflow design  
**Contributions**: Designed the multi-phase pipeline, defined YAML schemas, implemented blocking protocol, and wrote comprehensive documentation for the skill.

---

# Language Migration Skill

A systematic, multi-session, AI-executable workflow for migrating any open-source project
from one programming language to another with 1:1 structural fidelity.

## Core Principles

1. **No file is useless** — every file in the source project is analyzed and assigned a migration strategy
2. **Structural equivalence first** — algorithm steps, loop structure, and control flow must mirror the source; behavioral equivalence is only used when the ecosystem gap makes structural impossible
3. **No mock, ever** — tests must use real implementations and real test data
4. **Block, don't skip** — when a decision cannot be made autonomously, stop and ask the human; never label-and-continue
5. **State persists across sessions** — all state lives in YAML files in the workspace, readable by any AI agent or human
6. **Evidence before completion** — every unit of work must produce verifiable evidence of execution before being marked done

---

## Global Anti-Cheating Policy

This skill operates under the assumption that an AI agent may attempt to mark tasks complete
without actually doing the work. Every phase has mechanisms to detect and prevent this.

**The Three Forms of AI Task Fraud (all prohibited):**

| Form | Example | Detection |
|---|---|---|
| Batch fabrication | Scripts generate IPO content without reading source | source_lines field will be wrong/empty |
| Silent bulk-confirm | NEEDS_REVIEW → CONFIRMED without evidence | confirmation_evidence field empty |
| Premature phase advance | Marking P3 DONE when entries have empty fields | Self-verification checks fail |

**Evidence Requirements by Phase:**

| Phase | Required Evidence |
|---|---|
| P2 | `confirmation_evidence` block per CONFIRMED entry |
| P3 | `READ_EVIDENCE` + `BEHAVIOR_PROOF` per function; `source_lines` in every step; `source_line` on every magic

README.md

<div align="center">

```
╔═══════════════════════════════════════════════════════════════╗
║                                                               ║
║          ██╗      █████╗ ███╗   ██╗ ██████╗                   ║
║          ██║     ██╔══██╗████╗  ██║██╔════╝                   ║
║          ██║     ███████║██╔██╗ ██║██║  ███╗                  ║
║          ██║     ██╔══██║██║╚██╗██║██║   ██║                  ║
║          ███████╗██║  ██║██║ ╚████║╚██████╔╝                  ║
║          ╚══════╝╚═╝  ╚═╝╚═╝  ╚═══╝ ╚═════╝   flynn           ║
║                   M I G R A T I O N                           ║
║                                                               ║
╚═══════════════════════════════════════════════════════════════╝
```

# lang-migration

**A Formal Methodology for AI-Driven, Evidence-Obligated Program Translation**

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
[![Pairs: 14](https://img.shields.io/badge/Language_Pairs-14-blue)](#language-pairs)
[![Phase: P0–P6](https://img.shields.io/badge/Phases-P0_through_P6-green)](#pipeline)
[![Anti-Cheating](https://img.shields.io/badge/Anti--Cheating-Protocol_Enforced-red)](#the-evidence-obligation-protocol)
[![Works With](https://img.shields.io/badge/Works_With-Claude_Code_|_Cursor_|_Copilot_|_OpenCode-purple)](#runtime-environments)
[![ClawHub](https://clawhub.ai/favicon.ico)](https://clawhub.ai/suifei/lang-migration)
[![Version: 1.3](https://img.shields.io/badge/Version-1.3-blue)](#whats-new)

**English | [中文](README.zh-CN.md)**

*Migrate any open-source codebase across programming languages — with structural fidelity,
persistent state, and verifiable proof that the AI actually did the work.*

### ✨ **What's New**

**v1.3 — Bug Triage Protocol + Real-World Validation**
Every P5 test failure now goes through a mandatory 3-step triage before any fix is attempted.
Only 1 of 5 verdicts leads to modifying the translated function. Four new root cause categories.
Validated against a real Python→Go migration (GenericAgent → go-GenericAgent). [Learn more →](#bug-triage-protocol-classify-before-fix)

**v1.2 — Phase Gate Review (PGR)**
Every phase transition now requires passing an **autonomous self-auditing loop** before advancing.
The AI enumerates all expected outputs, audits each one, fixes any gap, and re-audits — until **zero findings**.
Only then is the phase marked DONE. No human involvement. No rubber-stamping. [Learn more →](CHANGELOG.md#v12--2026-05-15)

</div>

---

ClawHub: [https://clawhub.ai/suifei/lang-migration](https://clawhub.ai/suifei/lang-migration)

Skillhub:[https://skillhub.cn/skills/lang-migration](https://skillhub.cn/skills/lang-migration)

## The Problem Nobody Talks About

When developers ask an LLM to "migrate my Python project to Go," one of four things happens:

1. **The LLM produces plausible-looking code that silently drops behavior.** Type semantics, precision contr

_meta.json

{
  "ownerId": "kn731g0h1z4gandq3nq2dazb8186r61a",
  "slug": "lang-migration",
  "version": "1.3.1",
  "publishedAt": 1779071566759
}

references/lang-pairs/bun-python.md

# Language Pair: Bun (JavaScript) → Python

**Difficulty tier**: Low-Moderate (both dynamic; async models differ; number precision is a trap)

**Key differences**:
- Types: JS dynamic → Python `typing` annotations (ADD types; JS may have none)
- Async: JS Promise/async-await → Python `asyncio` (structurally similar)
- Numbers: JS `number` (float64) → Python `int` / `float` (must determine which)
- `undefined` vs `null`: JS has both → Python has only `None`
- Prototypal OOP: JS classes → Python classes (both ES6 class and Python class are similar)
- Modules: JS ESM → Python modules

---

## Pre-Mapped Core Types

| Bun (JS) | Python | Equivalence | Notes |
|---|---|---|---|
| `number` (integer use) | `int` | behavioral | JS uses float64 for all numbers; Python distinguishes |
| `number` (float use) | `float` | structural | |
| `bigint` | `int` | structural | Python int is natively arbitrary precision |
| `boolean` | `bool` | structural | |
| `string` | `str` | structural | JS is UTF-16 internally; Python str is abstract Unicode |
| `null` | `None` | structural | |
| `undefined` | `None` | behavioral | JS `undefined` (unset) → Python `None`; document |
| `Array<T>` | `list[T]` | structural | |
| `[A, B]` tuple | `tuple[A, B]` | structural | |
| `Map<K,V>` | `dict[K,V]` | structural | Both preserve insertion order |
| `Set<T>` | `set[T]` | structural | |
| `Uint8Array` | `bytes` | structural | |
| `ArrayBuffer` | `bytes` | structural | |
| `Promise<T>` | `Awaitable[T]` / coroutine | structural | |
| `null \| T` | `Optional[T]` | structural | |
| `A \| B` | `Union[A, B]` | structural | |

---

## Number Type Disambiguation

JS uses `number` for both integers and floats. When migrating, determine the correct Python type from context:

```javascript
// JS: all are `number`
const count = 42;           // → Python int
const ratio = 3.14;         // → Python float
const index = arr.length;   // → Python int
const price = 9.99;         // → Python float
```

**Decision rule** (apply per variable/parameter):
- Used with integer arithmetic, indices, or counts → `int`
- Used with decimal values, ratios, measurements → `float`
- Unclear → `float` (safer; Python float is wider than JS number)
- Was `bigint` in JS → always `int`

---

## `undefined` vs `null` → `None`

```javascript
// JS: different semantics
function find(key) {
    if (!map.has(key)) return undefined;  // not found
    const val = map.get(key);
    if (val === null) return null;         // explicitly absent
    return val;
}
```

```python
# Python: both → None; document the distinction as comment
def find(key: str) -> Optional[str]:
    # JS SOURCE: returned undefined when not found, null when explicitly absent.
    # Python: both map to None. Callers must not distinguish.
    if key not in self._map:
        return None   # was: undefined (not found)
    return self._map[key]   # may be None (was: null — explicitly absent)
```

If the caller distinguished `undefined` from `null`, use a senti

references/lang-pairs/c-python.md

# Language Pair: C → Python

**Difficulty tier**: Moderate (memory management dissolves; pointer arithmetic becomes indexing)

**Key differences**:
- Memory: C manual malloc/free → Python GC (ownership structures become irrelevant mechanically but must be documented)
- Pointers: C pointers → Python references or indices (never expose raw pointers)
- Types: C weak static → Python `typing` (strengthen, not weaken)
- Strings: C null-terminated `char*` → Python `str` (encoding must be made explicit)
- Error handling: C return codes + errno → Python exceptions
- Arrays: C fixed/dynamic arrays → Python `list` or `bytes`
- Structs: C structs → Python `dataclass` or class
- Function pointers: C `(*fn)(args)` → Python callable / `Callable`

---

## Pre-Mapped Core Types

| C | Python | Equivalence | Notes |
|---|---|---|---|
| `int8_t` | `int` | behavioral | Document original range: [-128, 127] |
| `int16_t` | `int` | behavioral | [-32768, 32767] |
| `int32_t` | `int` | behavioral | |
| `int64_t` | `int` | structural | Python int covers this range |
| `uint8_t` | `int` | behavioral | [0, 255]; add range assertion |
| `uint16_t` / `uint32_t` / `uint64_t` | `int` | behavioral | Document upper bound |
| `float` | `float` | behavioral | Python float is f64; C float is f32 — document precision widening |
| `double` | `float` | structural | |
| `_Bool` / `bool` | `bool` | structural | |
| `char*` (string) | `str` | behavioral | Must determine encoding; default UTF-8 |
| `char*` (bytes) | `bytes` | structural | When used as raw bytes, not text |
| `uint8_t*` + `size_t` | `bytes` | structural | |
| `void*` | `Any` | behavioral | Document what types it actually points to |
| `NULL` | `None` | structural | |
| `T*` (array) + `size_t n` | `list[T]` | structural | The (pointer, length) pair → single list |
| `T[N]` (fixed array) | `list[T]` | behavioral | Document that N was fixed; add `assert len(arr) == N` |
| `struct T` | `@dataclass` class | structural | |
| `enum` | `enum.IntEnum` or `enum.Enum` | structural | |
| `(*fn)(args) → ret` | `Callable[[args], ret]` | structural | |

---

## Pointer Pairs → Single Object

The most common C pattern — a pointer and its associated length — collapses to one Python object:

```c
// C: two parameters representing one logical unit
void process(const uint8_t *data, size_t len);
int find_max(const int *arr, size_t n);
char *join_strings(const char **strs, size_t count);
```

```python
# Python: one parameter
def process(data: bytes) -> None: ...
def find_max(arr: list[int]) -> int: ...
def join_strings(strs: list[str]) -> str: ...
```

**Rule**: Every `(T*, size_t)` pair in C source → one Python collection parameter.
Document the original C signature in a comment:

```python
def process(data: bytes) -> None:
    # C SOURCE: void process(const uint8_t *data, size_t len)
    ...
```

---

## Error Handling: Return Codes → Exceptions

**C:**
```c
typedef enum {
    ERR_OK = 0,
    ERR_NOT_FOUND = 1,
    ERR_INVALID_ARG = 2,
    ER

Github ReposUpdated 2d agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.