[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7CSRD8D974REV0GDMR7243H":3,"skill-same:01M7CSRD8D974REV0GDMR7243H":49},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":27,"commitSha":28,"skillDirectory":29,"forksCount":14,"repositoryHtmlUrl":30,"repositoryHomepageUrl":6,"ownerHtmlUrl":31,"ownerBlogUrl":32,"ownerDescription":33,"updatedAt":34,"install":35,"resources":48},"01M7CSRD8D974REV0GDMR7243H","schema-mapping",null,"Guides the process of analyzing, mapping, and documenting transformations between source and target schemas for any database, data warehouse, or data platform. Focuses exclusively on creating a high-fidelity mapping plan (Mapping Manifesto). Used when initiating an ETL, ELT, or data integration task with schema mapping specification for multiple tables (i.e. more than 3 tables) before writing code. Do NOT use this skill for basic SQL generation without mapping requirements, or when the user already has a complete mapping specification.","Henrique1601\u002FSkiilsToIAs","Henrique1601","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F92006691?v=4","01M7CRXVT0GVXVK80JT1GR687S","Henrique Bezerra Dos Santos","01M7CRXVTN5Y8TMWJ1MDSKCQ1T",0,"Apache-2.0","https:\u002F\u002Fgithub.com\u002FHenrique1601\u002FSkiilsToIAs\u002Fblob\u002Fmain\u002Fbackend-database\u002Fschema-mapping\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: schema-mapping\nlicense: Apache-2.0\ndescription: Guides the process of analyzing, mapping, and documenting transformations\n  between source and target schemas for any database, data warehouse, or data platform.\n  Focuses exclusively on creating a high-fidelity mapping plan (Mapping Manifesto).\n  Used when initiating an ETL, ELT, or data integration task with schema mapping specification\n  for multiple tables (i.e. more than 3 tables) before writing code. Do NOT use this\n  skill for basic SQL generation without mapping requirements, or when the user already\n  has a complete mapping specification.\nmetadata:\n  version: v1\n  publisher: google\n---\n\n# Skill: Semantic Schema Mapping Planning\n\nFollow this structured process and procedures for analyzing source-to-target\ndata relationships and creating a high-fidelity **Mapping Plan** (also known as\na **Mapping Manifesto**). This process is platform-agnostic and should be used\nbefore generating any target-specific pipeline code. When this skill is loaded,\nyou MUST use this plan and replace the existing generic plan.\n\n## When to Use\n\nUse this skill when:\n\n-   You need to map schemas between a source dataset\u002Fdatabase and a target\n    destination database\u002Fwarehouse.\n-   You are initiating an ETL, ELT, or data integration task.\n-   You need to identify schema gaps, data type conflicts, or aggregation\n    requirements.\n\n--------------------------------------------------------------------------------\n\n## Required Input Variables\n\nBefore creating the plan, you must obtain or request:\n\n1.  **`SOURCE_SCHEMAS`**: Definitions (schemas, tables, fields, types) of the\n    source data.\n2.  **`TARGET_SCHEMAS`**: Definitions of the desired target\u002Fdestination schemas.\n3.  **`BUSINESS_CONTEXT`**: Domain details, business rules, or use case\n    description.\n4.  **`TARGET_PLATFORM`**: The database or execution engine (e.g., BigQuery,\n    Snowflake, Postgres, Spark, Beam).\n\n## Optional Input Variables\n\n1.  **`KNOWLEDGE_GRAPH`**: If there's a knowledge graph \u002F property graph\n    available, always inspect the graph for node table definitions, edge table\n    definitions, and foreign key bindings (`SOURCE` \u002F `DESTINATION` key\n    references), etc.\n\n--------------------------------------------------------------------------------\n\n## The Schema Mapping Planning Procedure\n\n> [!IMPORTANT] **Execution Strategy: Table-by-Table Iteration**\n>\n> You MUST execute this procedure **iteratively, one target table at a time**.\n> For each individual table in the `TARGET_SCHEMAS`, complete Steps 1 through 6\n> sequentially before moving to the next table. Do not attempt to map or\n> summarize multiple tables in a single batch, as this leads to hallucinations,\n> overlooked constraints, and context window bloat.\n\n### Step 1: Semantic & Terminology Translation\n\nAnalyze the entity names and attributes in the `SOURCE_SCHEMAS` against the\n`TARGET_SCHEMAS`.\n\n1.  **Synonym Resolution**: Using the `BUSINESS_CONTEXT`, map matching concepts\n    with different names (e.g., `client_id` vs `customer_num`).\n2.  **Identify Domain Standards**: Match field values or formats to known\n    standards (e.g., ISO country codes, currency codes, UN\u002FLOCODE, UUIDs) based\n    on the business context.\n3.  **Verify Domain Semantics**: Do not rely purely on lexical matching (name\n    similarity). Verify the functional business purpose of the entities in both\n    schemas. Ensure that a target table representing a specific business\n    resource maps to a source table modeling that same resource rather than an\n    unrelated administrative log or generic list table sharing a similar name.\n\n### Step 2: Establish the Anchor Table\n\nFor each table or collection in the `TARGET_SCHEMAS`:\n\n1.  Identify the **primary source table** (the \"Anchor Table\") that holds the\n    core records for this target.\n2.  Identify **contributing\u002Flookup tables** in the source that will enrich the\n    target records.\n3.  **Prefer Structured Tables over Generic Key-Value Tables**: If the same\n    attribute exists in both a structured column in a domain table and as a\n    generic property in an Entity-Attribute-Value (EAV) key-value\u002Fproperties\n    table, always anchor on the structured table to ensure schema stability and\n    performant joins.\n\n### Step 3: Proactive Data Sampling & Inspection\n\nIf a target field mapping is ambiguous or schema types do not tell the whole\nstory (e.g., verifying if a timestamp is ISO-8601, if a string is a JSON array,\nor checking the distribution of values):\n\n1.  **Proactive Inspection**: If environment access allows, run\n    platform-specific queries (e.g., `SELECT ... LIMIT 10`, `SELECT\n    COUNT(DISTINCT ... )`) to sample values.\n2.  **User Inquiry**: If direct access is not possible, output sample queries\n    and ask the user to provide the output to confirm assumptions before\n    finalizing the plan.\n\n### Step 4: Perform Field-Level Gap Analysis & Cleanliness Design\n\nEvaluate every column in each target table to determine its source mapping.\nCategorize mappings and plan cleanliness transformations:\n\n*   **Direct Mapping**: A 1-to-1 match.\n*   **Derived Mapping**: Requires type casting, string manipulation, date\n    formatting, mathematical derivation, or case statement logic.\n*   **Joined Mapping**: Requires looking up values from contributing tables\n    using defined join keys.\n*   **Aggregated Mapping**: Requires collapsing 1-to-many relationships (e.g.,\n    calculating `SUM`, `COUNT`, `ARRAY_AGG` or string concatenation).\n*   **Gaps (Unmapped fields)**: Target fields that do not exist in the source.\n    *   **Constraint Checking**: Verify whether the target column has a `NOT\n        NULL` or `REQUIRED` constraint in the target schema.\n    *   **Handling Nullable Gaps**: If the target column is nullable, explicitly\n        flag it as `NULL` or define a default value.\n    *   **Handling Non-Nullable Gaps**: If the target column is `NOT NULL`, you\n        MUST NOT map it to `NULL`. *(Rationale: Mapping NOT NULL target columns\n        to NULL will cause execution-time database constraint violations and\n        pipeline failures).* You must identify a source field to derive it from,\n        default it to a valid non-null placeholder (e.g., `'UNKNOWN'`, `0`, or\n        default dates), or define logic to generate a valid unique reference.\n\n#### Universal Data Cleanliness Rules to Incorporate in Mappings:\n\n1.  **Null Standardization**: Map source strings like `\"NULL\"`, `\"None\"`,\n    `\"N\u002FA\"`, or empty spaces to true database `NULL` values.\n2.  **Trim & Casing**: Plan to trim leading\u002Ftrailing whitespaces. Convert\n    standardized codes (e.g., ISO codes, status strings) to uppercase.\n3.  **Temporal Consistency**: Plan to parse all source timestamps into standard\n    ISO-8601 format (`YYYY-MM-DDTHH:MM:SSZ`) or standard destination `TIMESTAMP`\n    format. Plan checks to ensure logical temporal progression (e.g.,\n    `start_time \u003C= end_time`).\n4.  **Defensive Checks**: Plan checks for strict destination types (e.g.,\n    checking if string is a valid number before casting to `DECIMAL`).\n\n### Step 5: Map Relationships & Joins\n\nSpecify the logical join path to connect the Anchor Table with all contributing\nsource tables:\n\n1.  Define the join condition\u002Fkeys (e.g., `source_order.customer_id =\n    source_customer.id`).\n2.  Identify join scale properties:\n    -   **Large-to-Large**: Joining two high-volume transaction tables.\n    -   **Large-to-Small**: Joining a transaction table to a static lookup table\n        (ideal for Map-side\u002FBroadcast joins to optimize speed\u002Fcost).\n3.  Document potential join challenges:\n    -   Many-to-many risks or potential duplicate generation.\n    -   Type mismatches on join keys (e.g., joining an `INT` column to a\n        `STRING` column).\n4.  **Graph Validation**: If a graph was identified in input, cross-reference\n    the proposed join conditions with the graph's edge table definitions to\n    validate foreign key relationships.\n\n### Step 6: Draft the \"Mapping Manifesto\" (Output Format & Example)\n\nAnalyze the schemas and reference the `ONE_SHOT_EXAMPLE` below to structure your\noutput.\n\n#### ONE_SHOT_EXAMPLE (How to Structure the Mapping Manifesto)\n\n##### Example Source Schemas\n\n```markdown\ndataset: my_music_library\nstyle: {id: int, style: string}\nband: {name: string, biography: string, style: int}\ncd: {name: string, year: int, artist: string, numbers: array\u003Cstring>}\ntrack: {id: string, number: int, name: string}\n```\n\n##### Example Target Schemas\n\n```markdown\ndataset: music_standard\nartist: {name: string, albums: array\u003Cstring>}\nalbum: {name: string, year: int, genre: string, tracks: array\u003Cstring>}\n```\n\n##### The Mapping Manifesto (Expected Output Format)\n\nFor each target table, document your column-to-column reasoning:\n\n```markdown\n# Mapping Plan: `album`\n* **Anchor Source Table**: `cd`\n* **Join Paths & Optimization**:\n    * `cd` JOIN `band` ON `cd.artist = band.name`\n    * `band` JOIN `style` ON `band.style = style.id`\n    * `cd` JOIN `track` ON `track.id IN UNNEST(cd.numbers)`\n\n### Field Mappings\n\n| Target Field | Source Field \u002F Logic | Mapping Type | Rationale \u002F Transformation Details |\n| :--- | :--- | :--- | :--- |\n| `album.name` | `cd.name` | Direct | A CD is a physical medium representing an album; direct semantic match |\n| `album.year` | `cd.year` | Direct | Direct semantic match for release year |\n| `album.genre` | `style.style` | Joined | Resolved via `cd.artist` -> `band.name` -> `band.style` (ID) -> `style.id` -> `style.style` (String) |\n| `album.tracks` | `ARRAY_AGG(track.name)` | Aggregated | Aggregation Point: Collapses 1-to-many track IDs in `cd.numbers` into an array of track names |\n```\n\n--------------------------------------------------------------------------------\n\n## Critical Operational Rules\n\n*   **Plan Before Execution**: You MUST NOT generate any ETL code,\n    target-specific pipeline configurations, or migration scripts until the\n    Mapping Manifesto has been presented to and approved by the user.\n    *(Rationale: Establishing clear mapping logic first prevents coding errors,\n    avoids circular dependencies, and ensures user alignment on semantic\n    mappings before wasting resources on implementation).*\n*   **Strict Schema Grounding**: Every source table and field name referenced in\n    the mapping plan MUST exactly match the names and data types present in the\n    provided `SOURCE_SCHEMAS`. You MUST NOT reference non-existent columns,\n    guess field names, or make assumptions about source schemas without\n    explicitly confirming them in the schema definitions. *(Rationale: Proposing\n    guesses leads to compilation errors and invalid mapping specifications).*\n*   **Target Schema Constraint Integrity**: You must never propose a mapping\n    that writes `NULL` to a column defined as `NOT NULL` or `REQUIRED` in the\n    `TARGET_SCHEMAS`.\n*   **Exhaustive Field Search**: Before declaring a target field as an \"Unmapped\n    \u002F Gap\", search all available source schemas to verify the data is not in a\n    less-obvious table. *(Rationale: Lazy mappings that default target fields to\n    NULL lead to downstream data loss and incomplete pipelines).*\n*   **Defensive Type Mapping**: Explicitly plan the transformation rules for\n    strict destination types (e.g. `TIMESTAMP`, `BOOLEAN`, `DECIMAL`) to avoid\n    load failures. *(Rationale: Different databases and platforms handle type\n    validation strictly; pre-planning casts prevents execution-time runtime\n    errors).*\n*   **Data Integrity Check**: Identify join conditions that could cause\n    Cartesian product expansion or data duplication, and note prevention\n    strategies in the plan. *(Rationale: Unvalidated joins can distort\n    aggregated metrics or exhaust processing memory on large datasets).*\n","# Skill: Semantic Schema Mapping Planning\n\nFollow this structured process and procedures for analyzing source-to-target\ndata relationships and creating a high-fidelity **Mapping Plan** (also known as\na **Mapping Manifesto**). This process is platform-agnostic and should be used\nbefore generating any target-specific pipeline code. When this skill is loaded,\nyou MUST use this plan and replace the existing generic plan.\n\n## When to Use\n\nUse this skill when:\n\n-   You need to map schemas between a source dataset\u002Fdatabase and a target\n    destination database\u002Fwarehouse.\n-   You are initiating an ETL, ELT, or data integration task.\n-   You need to identify schema gaps, data type conflicts, or aggregation\n    requirements.\n\n--------------------------------------------------------------------------------\n\n## Required Input Variables\n\nBefore creating the plan, you must obtain or request:\n\n1.  **`SOURCE_SCHEMAS`**: Definitions (schemas, tables, fields, types) of the\n    source data.\n2.  **`TARGET_SCHEMAS`**: Definitions of the desired target\u002Fdestination schemas.\n3.  **`BUSINESS_CONTEXT`**: Domain details, business rules, or use case\n    description.\n4.  **`TARGET_PLATFORM`**: The database or execution engine (e.g., BigQuery,\n    Snowflake, Postgres, Spark, Beam).\n\n## Optional Input Variables\n\n1.  **`KNOWLEDGE_GRAPH`**: If there's a knowledge graph \u002F property graph\n    available, always inspect the graph for node table definitions, edge table\n    definitions, and foreign key bindings (`SOURCE` \u002F `DESTINATION` key\n    references), etc.\n\n--------------------------------------------------------------------------------\n\n## The Schema Mapping Planning Procedure\n\n> [!IMPORTANT] **Execution Strategy: Table-by-Table Iteration**\n>\n> You MUST execute this procedure **iteratively, one target table at a time**.\n> For each individual table in the `TARGET_SCHEMAS`, complete Steps 1 through 6\n> sequentially before moving to the next table. Do not attempt to map or\n> summarize multiple tables in a single batch, as this leads to hallucinations,\n> overlooked constraints, and context window bloat.\n\n### Step 1: Semantic & Terminology Translation\n\nAnalyze the entity names and attributes in the `SOURCE_SCHEMAS` against the\n`TARGET_SCHEMAS`.\n\n1.  **Synonym Resolution**: Using the `BUSINESS_CONTEXT`, map matching concepts\n    with different names (e.g., `client_id` vs `customer_num`).\n2.  **Identify Domain Standards**: Match field values or formats to known\n    standards (e.g., ISO country codes, currency codes, UN\u002FLOCODE, UUIDs) based\n    on the business context.\n3.  **Verify Domain Semantics**: Do not rely purely on lexical matching (name\n    similarity). Verify the functional business purpose of the entities in both\n    schemas. Ensure that a target table representing a specific business\n    resource maps to a source table modeling that same resource rather than an\n    unrelated administrative log or generic list table sharing a similar name.\n\n### Step 2: Establish the Anchor Table\n\nFor each table or collection in the `TARGET_SCHEMAS`:\n\n1.  Identify the **primary source table** (the \"Anchor Table\") that holds the\n    core records for this target.\n2.  Identify **contributing\u002Flookup tables** in the source that will enrich the\n    target records.\n3.  **Prefer Structured Tables over Generic Key-Value Tables**: If the same\n    attribute exists in both a structured column in a domain table and as a\n    generic property in an Entity-Attribute-Value (EAV) key-value\u002Fproperties\n    table, always anchor on the structured table to ensure schema stability and\n    performant joins.\n\n### Step 3: Proactive Data Sampling & Inspection\n\nIf a target field mapping is ambiguous or schema types do not tell the whole\nstory (e.g., verifying if a timestamp is ISO-8601, if a string is a JSON array,\nor checking the distribution of values):\n\n1.  **Proactive Inspection**: If environment access allows, run\n    platform-specific queries (e.g., `SELECT ... LIMIT 10`, `SELECT\n    COUNT(DISTINCT ... )`) to sample values.\n2.  **User Inquiry**: If direct access is not possible, output sample queries\n    and ask the user to provide the output to confirm assumptions before\n    finalizing the plan.\n\n### Step 4: Perform Field-Level Gap Analysis & Cleanliness Design\n\nEvaluate every column in each target table to determine its source mapping.\nCategorize mappings and plan cleanliness transformations:\n\n*   **Direct Mapping**: A 1-to-1 match.\n*   **Derived Mapping**: Requires type casting, string manipulation, date\n    formatting, mathematical derivation, or case statement logic.\n*   **Joined Mapping**: Requires looking up values from contributing tables\n    using defined join keys.\n*   **Aggregated Mapping**: Requires collapsing 1-to-many relationships (e.g.,\n    calculating `SUM`, `COUNT`, `ARRAY_AGG` or string concatenation).\n*   **Gaps (Unmapped fields)**: Target fields that do not exist in the source.\n    *   **Constraint Checking**: Verify whether the target column has a `NOT\n        NULL` or `REQUIRED` constraint in the target schema.\n    *   **Handling Nullable Gaps**: If the target column is nullable, explicitly\n        flag it as `NULL` or define a default value.\n    *   **Handling Non-Nullable Gaps**: If the target column is `NOT NULL`, you\n        MUST NOT map it to `NULL`. *(Rationale: Mapping NOT NULL target columns\n        to NULL will cause execution-time database constraint violations and\n        pipeline failures).* You must identify a source field to derive it from,\n        default it to a valid non-null placeholder (e.g., `'UNKNOWN'`, `0`, or\n        default dates), or define logic to generate a valid unique reference.\n\n#### Universal Data Cleanliness Rules to Incorporate in Mappings:\n\n1.  **Null Standardization**: Map source strings like `\"NULL\"`, `\"None\"`,\n    `\"N\u002FA\"`, or empty spaces to true database `NULL` values.\n2.  **Trim & Casing**: Plan to trim leading\u002Ftrailing whitespaces. Convert\n    standardized codes (e.g., ISO codes, status strings) to uppercase.\n3.  **Temporal Consistency**: Plan to parse all source timestamps into standard\n    ISO-8601 format (`YYYY-MM-DDTHH:MM:SSZ`) or standard destination `TIMESTAMP`\n    format. Plan checks to ensure logical temporal progression (e.g.,\n    `start_time \u003C= end_time`).\n4.  **Defensive Checks**: Plan checks for strict destination types (e.g.,\n    checking if string is a valid number before casting to `DECIMAL`).\n\n### Step 5: Map Relationships & Joins\n\nSpecify the logical join path to connect the Anchor Table with all contributing\nsource tables:\n\n1.  Define the join condition\u002Fkeys (e.g., `source_order.customer_id =\n    source_customer.id`).\n2.  Identify join scale properties:\n    -   **Large-to-Large**: Joining two high-volume transaction tables.\n    -   **Large-to-Small**: Joining a transaction table to a static lookup table\n        (ideal for Map-side\u002FBroadcast joins to optimize speed\u002Fcost).\n3.  Document potential join challenges:\n    -   Many-to-many risks or potential duplicate generation.\n    -   Type mismatches on join keys (e.g., joining an `INT` column to a\n        `STRING` column).\n4.  **Graph Validation**: If a graph was identified in input, cross-reference\n    the proposed join conditions with the graph's edge table definitions to\n    validate foreign key relationships.\n\n### Step 6: Draft the \"Mapping Manifesto\" (Output Format & Example)\n\nAnalyze the schemas and reference the `ONE_SHOT_EXAMPLE` below to structure your\noutput.\n\n#### ONE_SHOT_EXAMPLE (How to Structure the Mapping Manifesto)\n\n##### Example Source Schemas\n\n```markdown\ndataset: my_music_library\nstyle: {id: int, style: string}\nband: {name: string, biography: string, style: int}\ncd: {name: string, year: int, artist: string, numbers: array\u003Cstring>}\ntrack: {id: string, number: int, name: string}\n```\n\n##### Example Target Schemas\n\n```markdown\ndataset: music_standard\nartist: {name: string, albums: array\u003Cstring>}\nalbum: {name: string, year: int, genre: string, tracks: array\u003Cstring>}\n```\n\n##### The Mapping Manifesto (Expected Output Format)\n\nFor each target table, document your column-to-column reasoning:\n\n```markdown\n# Mapping Plan: `album`\n* **Anchor Source Table**: `cd`\n* **Join Paths & Optimization**:\n    * `cd` JOIN `band` ON `cd.artist = band.name`\n    * `band` JOIN `style` ON `band.style = style.id`\n    * `cd` JOIN `track` ON `track.id IN UNNEST(cd.numbers)`\n\n### Field Mappings\n\n| Target Field | Source Field \u002F Logic | Mapping Type | Rationale \u002F Transformation Details |\n| :--- | :--- | :--- | :--- |\n| `album.name` | `cd.name` | Direct | A CD is a physical medium representing an album; direct semantic match |\n| `album.year` | `cd.year` | Direct | Direct semantic match for release year |\n| `album.genre` | `style.style` | Joined | Resolved via `cd.artist` -> `band.name` -> `band.style` (ID) -> `style.id` -> `style.style` (String) |\n| `album.tracks` | `ARRAY_AGG(track.name)` | Aggregated | Aggregation Point: Collapses 1-to-many track IDs in `cd.numbers` into an array of track names |\n```\n\n--------------------------------------------------------------------------------\n\n## Critical Operational Rules\n\n*   **Plan Before Execution**: You MUST NOT generate any ETL code,\n    target-specific pipeline configurations, or migration scripts until the\n    Mapping Manifesto has been presented to and approved by the user.\n    *(Rationale: Establishing clear mapping logic first prevents coding errors,\n    avoids circular dependencies, and ensures user alignment on semantic\n    mappings before wasting resources on implementation).*\n*   **Strict Schema Grounding**: Every source table and field name referenced in\n    the mapping plan MUST exactly match the names and data types present in the\n    provided `SOURCE_SCHEMAS`. You MUST NOT reference non-existent columns,\n    guess field names, or make assumptions about source schemas without\n    explicitly confirming them in the schema definitions. *(Rationale: Proposing\n    guesses leads to compilation errors and invalid mapping specifications).*\n*   **Target Schema Constraint Integrity**: You must never propose a mapping\n    that writes `NULL` to a column defined as `NOT NULL` or `REQUIRED` in the\n    `TARGET_SCHEMAS`.\n*   **Exhaustive Field Search**: Before declaring a target field as an \"Unmapped\n    \u002F Gap\", search all available source schemas to verify the data is not in a\n    less-obvious table. *(Rationale: Lazy mappings that default target fields to\n    NULL lead to downstream data loss and incomplete pipelines).*\n*   **Defensive Type Mapping**: Explicitly plan the transformation rules for\n    strict destination types (e.g. `TIMESTAMP`, `BOOLEAN`, `DECIMAL`) to avoid\n    load failures. *(Rationale: Different databases and platforms handle type\n    validation strictly; pre-planning casts prevents execution-time runtime\n    errors).*\n*   **Data Integrity Check**: Identify join conditions that could cause\n    Cartesian product expansion or data duplication, and note prevention\n    strategies in the plan. *(Rationale: Unvalidated joins can distort\n    aggregated metrics or exhaust processing memory on large datasets).*\n",{"name":5,"license":15,"metadata":24,"description":7},{"version":25,"publisher":26},"v1","google","main","a73152352c0612252131e5cf84e91312a6cf17dc","backend-database\u002Fschema-mapping","https:\u002F\u002Fgithub.com\u002FHenrique1601\u002FSkiilsToIAs","https:\u002F\u002Fgithub.com\u002FHenrique1601","https:\u002F\u002Fbezerraportifolio.netlify.app\u002F","Full Stack Developer | React, Next.js, TypeScript, Node.js & IA | Construindo produtos digitais e soluções SaaS","2026-11-15 02:56:04",{"source":8,"skillName":5,"commands":36,"prompt":46,"zipAvailable":47},[37,40,43],{"tool":38,"command":39},"npx","npx skills add Henrique1601\u002FSkiilsToIAs --skill schema-mapping",{"tool":41,"command":42},"bunx","bunx skills add Henrique1601\u002FSkiilsToIAs --skill schema-mapping",{"tool":44,"command":45},"pnpm","pnpm dlx skills add Henrique1601\u002FSkiilsToIAs --skill schema-mapping","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FHenrique1601\u002FSkiilsToIAs\u002Fblob\u002Fmain\u002Fbackend-database\u002Fschema-mapping\u002FSKILL.md",true,[],[50,58,65,72,79,86],{"skillNo":51,"name":52,"nameZh":6,"description":53,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":54,"licenseFileUrl":6,"sourceHtmlUrl":55,"categories":56,"keywords":57,"publishedAt":19},"01M7E2ANBW9V6AVX5JXNCEAWF8","rag-architect-agent","Agente Arquiteto de RAG, Embeddings & Busca Vetorial. Especialista em design e implementação de pipelines de Retrieval-Augmented Generation de alta fidelidade: chunking semântico, modelagem pgvector no PostgreSQL (Neon\u002FSupabase), busca híbrida (cosseno + BM25), reranking, validação via TypeSafe AI e filosofia Ponytail (anti-overengineering).","MIT","https:\u002F\u002Fgithub.com\u002FHenrique1601\u002FSkiilsToIAs\u002Fblob\u002Fmain\u002Fcustom-agents\u002Frag-architect-agent\u002FSKILL.md",[],[],{"skillNo":59,"name":60,"nameZh":6,"description":61,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":54,"licenseFileUrl":6,"sourceHtmlUrl":62,"categories":63,"keywords":64,"publishedAt":19},"01M7E29KKF8R02ZRGYE2MJM67G","rag-architecture-patterns","Padrões arquiteturais e implementação de pipelines RAG (Retrieval-Augmented Generation) de alta fidelidade para qualquer projeto ou sistema. Cobre chunking semântico, embeddings, busca híbrida (pgvector + BM25), reranking, validação via TypeSafe AI e filosofia Ponytail (anti-overengineering).","https:\u002F\u002Fgithub.com\u002FHenrique1601\u002FSkiilsToIAs\u002Fblob\u002Fmain\u002Fai-agents\u002Frag-architecture-patterns\u002FSKILL.md",[],[],{"skillNo":66,"name":67,"nameZh":6,"description":68,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":69,"categories":70,"keywords":71,"publishedAt":19},"01M7CWRA8E3BJ7CPY8N8EG28J1","skill-repair","Use this to fix and re-install agent skills that have failed installation.\nThis skill provides the necessary context and permissions to surgically update\nthe `manifest.json` after a fix has been applied.","https:\u002F\u002Fgithub.com\u002FHenrique1601\u002FSkiilsToIAs\u002Fblob\u002Fmain\u002Futilities\u002Fskill-repair\u002FSKILL.md",[],[],{"skillNo":73,"name":74,"nameZh":6,"description":75,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":54,"licenseFileUrl":6,"sourceHtmlUrl":76,"categories":77,"keywords":78,"publishedAt":19},"01M7CWR66FZP8FA47WVZ4Z2EXC","security-scan","Scan your Claude Code configuration (.claude\u002F directory) for security vulnerabilities, misconfigurations, and injection risks using AgentShield. Checks CLAUDE.md, settings.json, MCP servers, hooks, and agent definitions.","https:\u002F\u002Fgithub.com\u002FHenrique1601\u002FSkiilsToIAs\u002Fblob\u002Fmain\u002Futilities\u002Fsecurity-scan\u002FSKILL.md",[],[],{"skillNo":80,"name":81,"nameZh":6,"description":82,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":54,"licenseFileUrl":6,"sourceHtmlUrl":83,"categories":84,"keywords":85,"publishedAt":19},"01M7CWR0QPY58QPTR1P759TFNG","security-review","Use this skill when adding authentication, handling user input, working with secrets, creating API endpoints, or implementing payment\u002Fsensitive features. Provides comprehensive security checklist and patterns.","https:\u002F\u002Fgithub.com\u002FHenrique1601\u002FSkiilsToIAs\u002Fblob\u002Fmain\u002Futilities\u002Fsecurity-review\u002FSKILL.md",[],[],{"skillNo":87,"name":88,"nameZh":6,"description":89,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":54,"licenseFileUrl":6,"sourceHtmlUrl":90,"categories":91,"keywords":92,"publishedAt":19},"01M7CWQXCE40XWT4FZ3VWZFGDP","security-bounty-hunter","Hunt for exploitable, bounty-worthy security issues in repositories. Focuses on remotely reachable vulnerabilities that qualify for real reports instead of noisy local-only findings.","https:\u002F\u002Fgithub.com\u002FHenrique1601\u002FSkiilsToIAs\u002Fblob\u002Fmain\u002Futilities\u002Fsecurity-bounty-hunter\u002FSKILL.md",[],[]]