Skip to content

rse/ase / plugin/skills/ase-sync-import

ase-sync-import

Verified

Import information from foreign sources into a set of artifact kinds (the target), generating or updating them to reflect the imported information. Use when the user wants to "import", "ingest", or "bring in" external sources like files, URLs, or pasted text into artifacts like SPEC, CODE, DOCS, TASK, INFR, or OTHR.

FileKindSize
SKILL.mdskill md8.8 KB
help.mdmarkdown3.0 KB
---
name: ase-sync-import
argument-hint: "[--help|-h] [--target|-t <target>[,...]] <hint>"
description: >
    Import information from foreign sources into a set of artifact kinds
    (the target), generating or updating them to reflect the imported
    information. Use when the user wants to "import", "ingest", or
    "bring in" external sources like files, URLs, or pasted text into
    artifacts like SPEC, CODE, DOCS, TASK, INFR, or OTHR.
user-invocable: true
disable-model-invocation: false
effort: xhigh
---

@${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md

<purpose name="ase-sync-import">
Import Foreign Sources into Artifact Set
</purpose>

<expand name="getopt"
    arg1="ase-sync-import"
    arg2="--target|-t=SPEC">
    $ARGUMENTS
</expand>

<objective>
*Import* the information of the *foreign sources* (named by the
<hint/>) into the *target* artifact kinds, by reading the foreign
sources and generating or updating the target artifacts to faithfully
reflect the imported information:
<hint><getopt-arguments/></hint>.
</objective>

@${CLAUDE_SKILL_DIR}/../../meta/ase-format-meta.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-format-spec.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-format-task.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-tenets.md

Procedure
---------

<flow>

1.  <step id="STEP 1: Determine Target">

    1.  The recognized artifact kinds are the six tokens `TASK`,
        `SPEC`, `CODE`, `DOCS`, `INFR`, and `OTHR`. Parse
        <getopt-option-target/> as the comma-separated <target/> kind list.
        Upper-case and trim every parsed kind token. Do not output
        anything.

    2.  <if condition="<target/> is empty">

        Only output the following <template/> and then immediately *STOP*
        processing the entire current skill:

        <template>
        ⧉ **ASE**: ☻ skill: **ase-sync-import**, ▶ ERROR: empty target artifact list
        </template>

        </if>

    3.  If any token in <target/> is *not* one of the six recognized
        kinds, only output the following <template/> (with <kind/> set to
        the first offending token) and then immediately *STOP* processing
        the entire current skill:

        <template>
        ⧉ **ASE**: ☻ skill: **ase-sync-import**, ▶ ERROR: unknown or unsupported artifact kind: **<kind/>**
        </template>

    4.  <if condition="<hint/> is empty">

        Only output the following <template/> and then immediately *STOP*
        processing the entire current skill:

        <template>
        ⧉ **ASE**: ☻ skill: **ase-sync-import**, ▶ ERROR: empty source hint -- nothing to import from
        </template>

        </if>

    5.  Report the resolved target and source hint with the following <template/>:

        <template>
        ⧉ **ASE**: **TARGET**: <target/>
        ⧉ **ASE**: **SOURCE**: <hint/>
        </template>

    </step>

2.  <step id="STEP 2: Ingest Foreign Sources">

    1.  Do not output anything in this STEP 2.

    2.  Interpret the <hint/> as the description of the *foreign sources*
        to import from. The foreign sources are *external* to the ASE
        artifact sets and may be local files or directories, remote URLs,
        pasted text passages, or references to other documents.

    3.  Read or fetch all foreign sources named by the <hint/>: read local
        files and directories via the `Read` tool, and fetch remote URLs
        via the available web tools. Build a precise understanding of the
        *information* the foreign sources represent.

    </step>

3.  <step id="STEP 3: Generate or Update Artifacts">

    1.  For all kinds in <target/> except `TASK`, if any, call the
        `ase_artifact_list(kind: [ ... ])` tool of the `ase` MCP server
        *once*, passing the lower-cased `kind` tokens (*never* an empty
        list, as this resolves *all* kinds), and read the
        returned `artifacts` array of `{ kind, files }` objects to
        obtain the project-relative file list per kind. The `TASK` kind
        is *not* resolvable via `ase_artifact_list` (task plans are
        managed by the `ase_task_*` tools), so resolve and read it via
        the `ase_task_id` and `ase_task_load` tools instead. Read all
        *existing* target artifacts to understand their current state.

    2.  Internalize and honor the artifact-format conventions:

        -   the artifact-set meta information (`ase-format-meta.md`),
        -   the `SPEC` format, i.e. the SpecBook models and formats plus
            the SpecBook schema configuration of the project
            (`ase-format-spec.md`),
        -   the `TASK` format (`ase-format-task.md`).

        Whenever a target artifact belongs to one of these kinds, it
        *MUST* be kept (or made) conformant to the corresponding format
        (headings, structure, identifiers, references, and the
        `Modified:` timestamp rule). The kinds `CODE`, `DOCS`, `INFR`,
        and `OTHR` have no dedicated format contract and are treated as
        free-form.

    3.  You *MUST* internalize and strictly honor the **GENERIC TENETS**,
        the **CRAFTING TENETS**, and the **RECONCILIATION TENETS** of the
        **ASE Tenets** when generating or updating in the following, plus
        the **SPECIFYING TENETS** for every `SPEC` artifact. Do not output
        anything.

    4.  Call the `ase_timestamp(format: "yyyy-LL-dd HH:mm")` tool of the
        `ase` MCP server *once* to find out the current time and store it in
        <timestamp-modified/>.

    5.  *Generate or update* the <target/> artifact files so that they
        faithfully *reflect* the information of the imported foreign
        sources:

        -   *Generate* a target artifact that does not yet exist but is
            warranted by the imported information, using the current time
            for both its `Created:` and `Modified:` timestamps.

        -   *Update* an existing target artifact so it reflects the
            imported information. Keep changes as *surgical* as possible:
            change only what the imported information actually requires,
            and do *not* rewrite unrelated parts of an artifact. Whenever
            an existing artifact is changed and contains a `Modified:
            <timestamp-modified-old/>` line, replace this with `Modified:
            <timestamp-modified/>`.

        Honor **No Fabrication**: never invent target content the foreign
        sources do not support; if the sources are silent or ambiguous on
        something the target needs, surface the gap rather than guessing.
        Re-express the imported facts at the *target's* level of
        abstraction (a SPEC states intent and structure).

        Apply the generation/update directly to the target artifacts via
        the `Write`/`Edit` tools. For a `TASK` target, apply it via the
        `ase_task_save` MCP tool instead -- *NEVER* write a task plan
        file via `Write`/`Edit` or by executing a shell command.

    6.  <if condition="at least one `SPEC` artifact was generated or updated">

        Validate the specification by calling the `ase_specbook_lint()`
        tool of the `ase` MCP server and reading its returned
        `diagnostics` array of `{ file, line, column, severity, message }`
        objects. If it is not empty, fix the reported problems in the
        affected `SPEC` artifacts via the `Write`/`Edit` tools and call
        the tool again -- for at most *three* rounds in total. Do not
        output anything, unless diagnostics remain after the last round,
        in which case output the following <template/>, listing one
        bullet line per remaining diagnostic:

        <template>
        ⧉ **ASE**: **REMAINING DIAGNOSTICS**:

        -   `<file/>:<line/>:<column/>`: <message/>
        [...]
        </template>

        </if>

    7.  Report the performed changes with the following <template/>, listing
        one bullet line per generated or updated file (with <file/> its
        project-relative path and <note/> an ultra-brief description of
        what was imported):

        <template>
        ⧉ **ASE**: **IMPORTED ARTIFACTS**:

        -   `<file/>`: <note/>
        [...]
        </template>

        <if condition="no target artifact required any change">

        Only output the following <template/>:

        <template>
        ⧉ **ASE**: **IMPORTED ARTIFACTS**: none -- all targets already reflect the imported sources
        </template>

        </if>

    8.  Finally, give the closing hint by expanding the following (which,
        depending on the configured <ase-guidance-level/>, may expand
        into nothing and hence emit no output at all):

        <if condition="at least one target artifact was generated or updated">
        <ase-tpl-hint level="normal">
        To propagate the imported information to the remaining artifact kinds, use `/ase-sync-reconcile`.
        </ase-tpl-hint>
        </if>

    </step>

</flow>
rea-changelog-updatemorluto/reaPrepare or rewrite REA release changelogs and GitHub release notes from pinned Git history, with verified contributor thanks and Release Please synchronization.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
academy-guideanthropics/skillsStop and check this skill before finishing any reply to a question about how to use Claude or a Claude product — it recommends matching courses, tutorials, and use cases from Claude Academy (academy.claude.com), Anthropic's learning hub. Trigger on: "how do I", "how can I", "getting started with", "what can Claude do", "teach me", "learn to use"; questions about artifacts, projects, skills, plugins, connectors, MCP; requests about rolling Claude out to a team, class, or organization; and any ask for training materials, onboarding content, or learning resources. Use it when the user is learning how to use a feature or product — not when they are mid-task and just want the task done. This skill composes with other skills: after consulting product documentation to answer how a Claude feature works, also check here for a matching course or tutorial — a docs-grounded answer and an Academy recommendation belong together. Only recommend on a strong match; never invent Academy content.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
claude-apianthropics/skillsReference for the Claude API / Anthropic SDK — model ids, pricing, params, streaming, tool use, MCP, agents, caching, token counting, model migration. TRIGGER — read BEFORE opening the target file; don't skip because it "looks like a one-liner" — whenever: the prompt names Claude/Anthropic in any form (Claude, Anthropic, Fable, Opus, Sonnet, Haiku, `anthropic`, `@anthropic-ai`, `claude-*`, `us.anthropic.*`, `[1m]`); the user asks about an LLM (pricing/model choice/limits/caching) — never answer from memory; OR the task is LLM-shaped with provider unstated (agent/MCP/tool-definition/multi-agent/RAG/LLM-judge/computer-use; generate/summarize/extract/classify/rewrite/converse over NL; debugging refusals/cutoffs/streaming/tool-calls/tokens). SKIP only when another provider is being worked on (overrides all triggers): OpenAI/GPT/Gemini/Llama/Mistral/Cohere/Ollama named in the query; OR `grep -rE 'openai|langchain_openai|google.generativeai|genai|mistralai|cohere|ollama'` over the project hits (run this grep FIRST if no provider named — don't Read the file).Stars: 198kUpdated Claude CodeCodexUnverifiedInstall
doc-coauthoringanthropics/skillsGuide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision docs, or similar structured content. This workflow helps users efficiently transfer context, refine content through iteration, and verify the doc works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, or similar documentation tasks.Stars: 198kUpdated Claude CodeCodexVerifiedInstall