Ase Arch Discover

@${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

$ARGUMENTS

2.  If <functionality/> 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
    <user-dialog-tool/> tool! Instead, you *MUST* just show a
    custom dialog according to the expanded `custom-dialog`
    definition. You *MUST* closely follow this definition:

    <expand name="custom-dialog" arg1="--no-other">
        Functionality: Which functionality should the components provide?
        <answer-1/>: (grounded candidate functionality 1)
        <answer-2/>: (grounded candidate functionality 2)
        <answer-3/>: (grounded candidate functionality 3)
        <answer-4/>: (grounded candidate functionality 4)
    </expand>

    Then use the <result/> and its corresponding grounded candidate
    functionality to adjust <functionality/> accordingly.

3.  Display the determined final functionality with just the following
    <template/>:

    <template>
    <ase-tpl-bullet-normal/> **FUNCTIONALITY**: <functionality/>
    </template>
</step>

2. 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 <stack>TypeScript</stack>.
   
   2.  Else, if a file `package.json` is found in the top-level directory
       of the project, then <stack>JavaScript</stack>.
   
   3.  Else, if a file `build.gradle.kts` or `settings.gradle.kts`
       is found in the top-level directory, then <stack>Kotlin</stack>.
   
   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 <stack>Kotlin</stack>.
   
   5.  Else, if a file `pom.xml` is found in the top-level directory and
       contains `kotlin-maven-plugin` or `kotlin-stdlib` dependencies, then
       <stack>Kotlin</stack>.
   
   6.  Else, if a file `pom.xml` or `build.gradle` is found in the top-level directory
       of the project, then <stack>Java</stack>.
   
   7.  Else, use <stack>Unknown</stack>.
   

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

3. <template>
   <ase-tpl-bullet-normal/> **RESULT**: technology stack could not be determined -- component discovery is only supported for JavaScript, TypeScript, Java, and Kotlin projects.
   </template>
   

   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 × ). 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 <pool/> "<keyword-1/>" [...] "<keyword-M/>" 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=<keyword-1/>+[...]+<keyword-M/>&rows=<pool/>&wt=json' to specifically discover an additional set of a maximum of Maven packages and at least their unique Maven coordinates (i.e. <g/>:<a/> 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: "<stack/>", components: [ "<package-1/>", ..., "<package-C/>" ]) 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 <type/>: <hint/> where is one of USP, Crux, or Gotcha and is a 1-6 word hint. Do not output anything.

4. <template>
   <ase-tpl-bullet-normal/> **COMPONENT HINTS**:
   
   | ⚑ *Component* | ▣ *Package*    | ⚖ *Hint*  |
   | :------------ | :------------- | :-------- |
   | **<name-1/>** | `<package-1/>` | <info-1/> |
   [...]
   | **<name-N/>** | `<package-N/>` | <info-N/> |
   </template>
   

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

      ⚑ Component	▣ Package	❖ Version	↓ Downloads	⎈ Stars	⏲ Updated	☆ Created
      	<package-1/>
      [...]
      	<package-N/>