# Ase Arch Discover

> >

- **Type:** Skill
- **Install:** `agentstack add skill-rse-ase-ase-arch-discover`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [rse](https://agentstack.voostack.com/s/rse)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** Apache-2.0
- **Upstream author:** [rse](https://github.com/rse)
- **Source:** https://github.com/rse/ase/tree/master/plugin/skills/ase-arch-discover
- **Website:** https://ase.tools

## Install

```sh
agentstack add skill-rse-ase-ase-arch-discover
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

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

Discover Components

    $ARGUMENTS

*Discover* additional, *third-party components* (libraries/frameworks)
for the technology stack to *provide* the *needed functionality*
.

1.  
    1.  Derive the needed  from the , but keep
        the functionality description very *brief* but still *precise*.

    2.  If  is not clear, not precise, or not specific
        enough, let the *user interactively choose* the intended
        functionality.

        In the following, you *MUST* *NOT* use your built-in
         tool! Instead, you *MUST* just show a
        custom dialog according to the expanded `custom-dialog`
        definition. You *MUST* closely follow this definition:

        
            Functionality: Which functionality should the components provide?
            : (grounded candidate functionality 1)
            : (grounded candidate functionality 2)
            : (grounded candidate functionality 3)
            : (grounded candidate functionality 4)
        

        Then use the  and its corresponding grounded candidate
        functionality to adjust  accordingly.

    3.  Display the determined final functionality with just the following
        :

        
         **FUNCTIONALITY**: 
        
    

2.  
    1.  Determine the used technology stack:

        1.  If a file `package.json` is found in the top-level directory
            of the project and contains an entry `typescript` under `dependencies`
            or `devDependencies`, then TypeScript.

        2.  Else, if a file `package.json` is found in the top-level directory
            of the project, then JavaScript.

        3.  Else, if a file `build.gradle.kts` or `settings.gradle.kts`
            is found in the top-level directory, then Kotlin.

        4.  Else, if a file `build.gradle` is found in the top-level directory and
            is applying `kotlin`, `org.jetbrains.kotlin.jvm`, `kotlin-android`,
            or `kotlin-multiplatform` plugins, then Kotlin.

        5.  Else, if a file `pom.xml` is found in the top-level directory and
            contains `kotlin-maven-plugin` or `kotlin-stdlib` dependencies, then
            Kotlin.

        6.  Else, if a file `pom.xml` or `build.gradle` is found in the top-level directory
            of the project, then Java.

        7.  Else, use Unknown.

    2.  Display the determined final technology stack with just the
        following :

        
         **TECHNOLOGY STACK**: 
        
    

3.  
    1.  If  is "Unknown", the technology stack could not be
        determined and no component discovery backend is available.
        Inform the user with just the following  and then
        *STOP* the entire flow (do not perform any further steps):

        
         **RESULT**: technology stack could not be determined -- component discovery is only supported for JavaScript, TypeScript, Java, and Kotlin projects.
        

    2.  From  and , derive essential keywords
         (L=1-M), which allow you to search for suitable
        components.

    3.  Determine the *candidate pool size*  as twice the
         (i.e.  = 2 &times;
        ). Each discovery source below may fetch up
        to  candidates so that the later ranking and trimming
        (which alone is governed by ) has a
        meaningful set to choose from.

        In the to be discovered candidate set of components 
        (K=1-C, where C is the merged and deduplicated candidate count),
        remember the component name as , the
        official package name as , the latest version as
        , the stars as , the created date as
        , the last updated date as , the total
        number of downloads in the last month as .

    4.  If  is "JavaScript" or "TypeScript":

        1.  Based on the essential keywords  (L=1-M),
            use the `ase-meta-search` skill in a subagent to *generally*
            discover an initial set of a maximum of  *NPM packages*
             and at least their real name  and
            their unique package names .

        2.  Use the shell command `npm search --json --searchlimit 
            "" [...] ""` to *specifically*
            discover an additional set of a maximum of  *NPM packages*
             and at least their unique package names
            , based on the essential keywords 
            (L=1-M). Merge the results into the already existing result
            set, but deduplicate entries.

    5.  If  is "Java" or "Kotlin":

        1.  Based on the essential keywords  (L=1-M),
            use the `ase-meta-search` skill in a subagent to *generally*
            discover an initial set of a maximum of  *Maven packages*
             and at least their real name  and
            their unique Maven coordinates  of the form
            `groupId:artifactId`.

        2.  Use the shell command `curl -s 'https://search.maven.org/solrsearch/select?q=+[...]+&rows=&wt=json'`
            to *specifically* discover an additional set of a maximum
            of  *Maven packages*  and at least their
            unique Maven coordinates  (i.e. `:` from
            each result document's `g` and `a` fields), based on the
            essential keywords  (L=1-M). Merge the results
            into the already existing result set, but deduplicate
            entries by Maven coordinate.

    6.  Call the `ase_component_info(stack: "", components:
        [ "", ..., "" ])` tool of the `ase` MCP
        server *once* for the entire candidate set of discovered packages.
        The tool dispatches internally on  and fetches all
        metadata in maximum parallel and returns an array of objects `{
        name, version, created, updated, repository, stars, downloads,
        rank }`. For each
        component  (K=1-C) read from its corresponding
        entry:  from `version`,  from `updated`,
         from `created`,  from `repository`,
         from `stars` (numeric or `N.A.`), 
        from `downloads` (numeric or `N.A.`) and  from `rank`
        (numeric).

    7.  Sort, in descending order, the discovered candidate components
         (K=1-C) by their `rank` field and trim the result
        list to just a maximum of  total components,
        which establishes the final retained set  (K=1-N,
        where N is at most ). All subsequent steps
        operate solely on this retained set.

    8.  For each component  (K=1-N), research and then
        decide which *one* of *USP* (Unique Selling Point -- what makes
        it unique), *Crux* (what you should notice), or *Gotcha* (what
        you should not stumble over) is its single most distinguishing
        perspective, and remember this as an  (K=1-N) formatted
        like `: ` where  is one of `USP`, `Crux`,
        or `Gotcha` and  is a 1-6 word hint. Do not output
        anything.
    

4.  
    1.  Display the determined, individual components as a Markdown
        *table* with just the following  and do not output
        anything else:

        
         **COMPONENT HINTS**:

        | ⚑ *Component* | ▣ *Package*    | ⚖ *Hint*  |
        | :------------ | :------------- | :-------- |
        | **** | `` |  |
        [...]
        | **** | `` |  |
        

    2.  Display the discovered components as a Markdown *table*
        with just the following :

        
         **COMPONENT RANKING**:

        | ⚑ *Component* | ▣ *Package*    | ❖ *Version*  | ↓ *Downloads*      | ⎈ *Stars*      | ⏲ *Updated*      | ☆ *Created*  |
        | :------------ | :------------- | -----------: | -----------------: | -------------: | :--------------- | :----------- |
        | **** | `` |  | **** | **** | **** |  |
        [...]
        | **** | `` |  | **** | **** | **** |  |

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [rse](https://github.com/rse)
- **Source:** [rse/ase](https://github.com/rse/ase)
- **License:** Apache-2.0
- **Homepage:** https://ase.tools

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** yes
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-rse-ase-ase-arch-discover
- Seller: https://agentstack.voostack.com/s/rse
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.
