@rse/ase 1.0.7 → 2.0.1

package/plugin/skills/ase-code-craft/SKILL.md

@@ -1,264 +0,0 @@
----
-name: ase-code-craft
-argument-hint: "[--help|-h] [--auto|-a] [--dry|-d] [--direct|-D] [--interactive|-i] [--quick|-Q] [--next|-n <option>[,...]] [<task-id>:] <feature>"
-description: >
-    Craft Source Code:
-    Use when user wants to "create", "add", or "craft" a new feature from scratch.
-user-invocable: true
-disable-model-invocation: false
-effort: xhigh
-allowed-tools:
-    - "Skill"
-    - "Agent"
-    - "Read"
----
-
-@${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
-
-<purpose name="ase-code-craft">
-Craft Source Code
-</purpose>
-
-<expand name="getopt"
-    arg1="ase-code-craft"
-    arg2="--auto|-a --dry|-d --direct|-D --interactive|-i --quick|-Q --next|-n=(none|DONE|EDIT|GRILL|PREFLIGHT|IMPLEMENT)...">
-    $ARGUMENTS
-</expand>
-
-<if condition="<getopt-option-quick/> is equal `true`">
-The `--quick`/`-Q` flag is a *shorthand alias*: set <getopt-option-auto/>
-to `true`, <getopt-option-dry/> to `true`, and <getopt-option-next/> to
-`IMPLEMENT,DELETE`. Do not output anything.
-</if>
-
-<if condition="<getopt-option-interactive/> is equal `true`">
-The `--interactive`/`-i` flag *implies* the `--direct`/`-D` mode: set
-<getopt-option-direct/> to `true`. Do not output anything.
-</if>
-
-<objective>
-From scratch *craft* the following feature:
-<feature><getopt-arguments/></feature>
-</objective>
-
-@${CLAUDE_SKILL_DIR}/../../meta/ase-format-task.md
-@${CLAUDE_SKILL_DIR}/../../meta/ase-tenets.md
-@${CLAUDE_SKILL_DIR}/../../meta/ase-common-code.md
-
-Procedure
----------
-
-<if condition="<getopt-option-direct/> is not equal to 'true'">
-You *MUST* *NOT* call `Edit`, `Write`, `NotebookEdit`, or any
-filesystem-modifying tool, nor execute any filesystem-modifying
-shell command, during this entire skill. The *only* permitted way
-to persist artifacts is via the `ase_task_save(...)` MCP tool.
-</if>
-<else>
-The `--direct`/`-D` mode applies the crafting *in place*, so STEP 4
-below *requires* `Edit` and `Write` to modify the affected artifacts.
-Every modification *MUST* still stay restricted to the artifacts the
-crafting actually demands, and you *MUST* *NOT* call
-`ase_task_save(...)`, as no task plan is composed at all.
-</else>
-
-<flow>
-
-1.  <step id="STEP 1: Reason About Feature">
-
-    1.  <if condition="
-            <feature/> matches the regexp `^[a-zA-Z][a-zA-Z0-9_-]*$`
-        ">
-        Set <ase-task-id><feature/></ase-task-id> (set task id to feature)
-        and <feature></feature> (set feature empty), call the
-        `ase_task_id(id: "<ase-task-id/>", session: "<ase-session-id/>")` tool
-        from the `ase` MCP server to switch the task, and then only
-        output the following <template/>:
-
-        <template>
-        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **task given**
-        </template>
-        </if>
-
-    2.  <if condition="
-            <feature/> has the format `<id/>: <text/>` AND
-            <id/> matches the regexp `^[a-zA-Z][a-zA-Z0-9_-]*$`
-        ">
-        Set <feature><text/></feature> and
-        <ase-task-id><id/></ase-task-id> and call the `ase_task_id(id:
-        "<ase-task-id/>", session: "<ase-session-id/>")` tool from the
-        `ase` MCP server to implicitly switch the task. Do not output
-        anything.
-        </if>
-
-    3.  <if condition="<feature/> is empty">
-        Ask the user interactively, without a special tool, for the
-        initial feature with a single question:
-
-        `**No feature known yet. What is the feature you want to craft?**`
-
-        Then set <feature/> to the response of the user.
-        </if>
-
-    4.  <if condition="
-            <ase-task-id/> is equal `default` and
-            <feature/> is not empty
-        ">
-        Set <ase-task-id/> to a unique task id, derived from <feature/>,
-        which consists of two lower-case words concatenated with a
-        `-` character. Then call the `ase_task_id(id: "<ase-task-id/>",
-        session: "<ase-session-id/>")` tool from the `ase` MCP server to
-        implicitly switch the task. Do not output anything.
-        </if>
-
-    5.  Report the task and feature with the following <template/>:
-
-        <template>
-        ⧉ **ASE**: ◉ task: **<ase-task-id/>**
-        ⧉ **ASE**: ⇌ feature: **<feature/>**
-        </template>
-
-    6.  Figure out what the requested <feature/> to be crafted is about.
-
-    7.  Ask the user for clarification if the goal of this crafting is too
-        unclear.
-
-    8.  Do not output anything else in this step, unless you asked the user.
-
-    </step>
-
-2.  <step id="STEP 2: Investigate Code Base">
-
-    1.  Check the existing source files for all code which is related to the
-        requested new <feature/>.
-
-    2.  Check the architecture of the existing code base to understand the
-        overall structures and dynamics.
-
-    3.  Do not output anything in this STEP 2.
-
-    </step>
-
-3.  <step id="STEP 3: Internalize Crafting Tenets">
-
-    1.  <task-kind>CRAFTING</task-kind>
-
-    2.  <expand name="code-tenets" arg1="<task-kind/>"></expand>
-
-    3.  Do not output anything in this STEP 3.
-
-    </step>
-
-4.  <if condition="<getopt-option-direct/> is equal to 'true'">
-
-    <step id="STEP 4: Direct Feature Crafting">
-
-    1.  Directly craft the <feature/> by modifying the affected
-        *artifacts* with a corresponding, complete *change set*,
-        based on your gathered knowledge about the code base and your
-        internalized crafting tenets. Also, if a CHANGELOG.md
-        file exists, make an appropriate entry there, too.
-
-    2.  Output only the following <template/>:
-
-        <template>
-        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **changes directly applied**
-        </template>
-
-    3.  <if condition="<getopt-option-interactive/> is equal `true`">
-        Enter the *interactive crafting loop*:
-
-        <while condition="`true`">
-
-        1.  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.
-
-            Ask the user for the next change with the following
-            custom dialog:
-
-            <expand name="custom-dialog" arg1="--other">
-                Next Change: What is the next change to craft?
-                DONE: Finish the interactive crafting loop
-            </expand>
-
-        2.  If <result/> is `DONE` or `CANCEL`, <break/>.
-
-        3.  Otherwise <result/> has the format `OTHER: <text/>`: set
-            <feature/> to <text/>, then directly craft it and report
-            it exactly as specified by the items 1 and 2 above
-            (including the CHANGELOG.md entry).
-
-        </while>
-        </if>
-
-    4.  Then *IMMEDIATELY* *STOP* all further skill processing. You
-        *MUST* *NOT* output anything else in this STEP 4 or after it --
-        *independent* of <ase-project-boxing/>, whose exposure rules
-        are explicitly *overridden* here. Especially, do not output a
-        change summary, a list of modified artifacts, a rationale, or
-        a unified diff of the changes.
-
-    </step>
-
-    </if>
-    <else>
-
-    <step id="STEP 4: Choose Feature Crafting Approaches">
-
-    <expand name="code-approaches" arg1="feature" arg2="crafting"></expand>
-
-    </step>
-
-    <step id="STEP 5: Compose Feature Crafting Plan">
-
-    1.  *Compose a feature plan* for the chosen feature A<n/> by
-        closely aligning to the existing architecture and the existing
-        code base. Use the <format/> defined for a task plan and inject
-        the information from feature A<n/> and all derived realization
-        decisions into it. Store the resulting task plan in <task-content/>.
-
-        If a `CHANGELOG.md` file exists in the project (or in any
-        affected sub-package), the plan *MUST* include, as part of its
-        `##  CHANGES` section, an explicit bullet point describing
-        the addition of a corresponding new entry to that `CHANGELOG.md`
-        file, aligned with its existing style and conventions.
-
-        <if condition="<getopt-option-dry/> is equal `true`">
-        You *MUST* completely omit the `##  VERIFICATION` section
-        (including its heading and all of its bullet points) from
-        <task-content/>.
-        </if>
-
-        You *MUST* *NOT* call `Edit`, `Write`, `NotebookEdit`, or any
-        filesystem-modifying tool during this step.
-
-    2.  Call the `ase_timestamp(format: "yyyy-LL-dd HH:mm")` tool of the
-        `ase` MCP server and use the `text` field of its response for
-        <timestamp-created/> and <timestamp-modified/> information. Then
-        insert the current <ase-task-id/>, <timestamp-created/>,
-        <timestamp-modified/>, and <task-kind/> information.
-
-    3.  You then *MUST* *save* the resulting plan content with the
-        `ase_task_save(id: "<ase-task-id/>", text: "<task-content/>")`
-        MCP tool call only -- *NEVER* by executing a shell command.
-
-    4.  Output a hint with the following <template/>:
-
-        <template>
-        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan created**
-        </template>
-
-    5.  Directly pass-through control to the next skill:
-
-        <expand name="code-next-dispatch"></expand>
-
-    </step>
-
-    </else>
-
-</flow>

package/plugin/skills/ase-code-craft/help.md

@@ -1,122 +0,0 @@
-
-##  NAME
-
-`ase-code-craft` - Craft Source Code
-
-##  SYNOPSIS
-
-`ase-code-craft`
-    [`--help`|`-h`]
-    [`--auto`|`-a`]
-    [`--dry`|`-d`]
-    [`--direct`|`-D`]
-    [`--interactive`|`-i`]
-    [`--quick`|`-Q`]
-    [`--next`|`-n` *option*[,...]]
-    [*task-id*:] *feature*
-
-##  DESCRIPTION
-
-The `ase-code-craft` skill crafts a *new feature* from scratch by
-investigating the existing code base, internalizing crafting tenets
-(KISS, YAGNI, DRY, SRP, loose coupling, ...), proposing one or more
-*feature approaches* with pros and cons, letting the user pick the
-preferred approach, and composing a corresponding *task plan* aligned
-with the existing architecture.
-
-By default the skill does *not* directly modify source files. It
-persists the plan via `ase_task_save` and then hands off to
-`ase-task-edit`, `ase-task-preflight`, or `ase-task-implement`, as
-selected by `--next`. Only under `--direct` it skips the plan
-entirely and applies the change set to the affected artifacts itself.
-
-##  OPTIONS
-
--   `--auto`|`-a`:
-    Automatically pick the recommended feature approach without
-    asking the user via the interactive dialog.
-
--   `--dry`|`-d`:
-    Compose the plan *without* the `##  VERIFICATION` section. When
-    `ase-task-implement` later applies such a plan, it strictly skips
-    the entire verification phase (no build, tests, linter,
-    type-checker, or program execution) once the source files have
-    been modified.
-
--   `--direct`|`-D`:
-    Craft the feature *immediately* and *in place*: skip the
-    feature approaches, the interactive dialog, and the entire task
-    plan ceremony, and directly apply the complete change set to the
-    affected artifacts, including a corresponding entry in an existing
-    `CHANGELOG.md` file. In this mode `--auto`, `--dry`, `--quick`, and
-    `--next` have no effect, as neither approaches are proposed nor a
-    plan is composed.
-
--   `--interactive`|`-i`:
-    Craft *interactively*: implies `--direct` and, once the initial
-    *feature* has been applied, repeatedly asks for the *next change*
-    with a free-text dialog and immediately applies it in place, too,
-    until the user stops the loop by answering `DONE`.
-
--   `--quick`|`-Q`:
-    Shorthand alias for `-a -d -n IMPLEMENT,DELETE`: automatically pick
-    the recommended feature approach, compose the plan *without* the
-    `##  VERIFICATION` section, immediately hand off to `ase-task-implement`,
-    and finally `ase-task-delete` the now-consumed plan. This gives a
-    single, fast *one-shot* crafting mode.
-
--   `--next`|`-n` *option*[,...]:
-    Automatically choose the next step after composing the plan.
-    *option* is a single token or a *comma-separated chronological
-    list* of tokens; an `IMPLEMENT`, `PREFLIGHT`, or `GRILL` head token
-    is consumed by this skill (bypassing `ase-task-edit`), and any
-    remaining tokens are *forwarded* (via `--next`) to the downstream
-    skill. For all other head tokens, the *entire* list is forwarded
-    to `ase-task-edit`, which consumes its head itself. This lets an
-    entire pipeline be pre-scripted in one shot. Recognized tokens at
-    this skill: `none` (default, hand off to `ase-task-edit`
-    interactively), `DONE` (stop), `EDIT` (hand off to
-    `ase-task-edit`), `GRILL` (hand off to `ase-task-grill`),
-    `PREFLIGHT` (hand off to `ase-task-preflight`),
-    or `IMPLEMENT` (hand off to `ase-task-implement`). Example:
-    `--next PREFLIGHT,IMPLEMENT,DONE` crafts the plan, preflights it,
-    implements it, and exits without further dialog.
-
-##  ARGUMENTS
-
--   [*task-id*:] *feature*:
-    Description of the *feature* to craft. Optionally prefixed with
-    a *task-id* followed by a colon to bind the resulting plan to
-    a specific task id.
-
-##  SCENARIOS
-
--   You want to add a new feature to the code base
--   You want feature approaches with pros and cons before any code changes
--   You want a task plan composed for building something new
--   You want a fast one-shot crafting without any plan ceremony
-
-##  EXAMPLES
-
-Craft a new logging feature:
-
-```text
-❯ /ase-code-craft add structured JSON logging with log levels
-```
-
-Craft a feature under a named task and directly hand off to implementation:
-
-```text
-❯ /ase-code-craft --next IMPLEMENT auth: add JWT authentication middleware
-```
-
-Craft interactively, applying one change after the other in place:
-
-```text
-❯ /ase-code-craft -i add a --verbose option to the CLI
-```
-
-##  SEE ALSO
-
-[`ase-code-refactor`](../ase-code-refactor/help.md), [`ase-code-resolve`](../ase-code-resolve/help.md), [`ase-task-edit`](../ase-task-edit/help.md),
-[`ase-task-grill`](../ase-task-grill/help.md), [`ase-task-preflight`](../ase-task-preflight/help.md), [`ase-task-implement`](../ase-task-implement/help.md).

package/plugin/skills/ase-code-refactor/SKILL.md

@@ -1,232 +0,0 @@
----
-name: ase-code-refactor
-argument-hint: "[--help|-h] [--auto|-a] [--dry|-d] [--direct|-D] [--quick|-Q] [--next|-n <option>[,...]] [<task-id>:] <request>"
-description: >
-    Refactor Code:
-    Use when user wants to "refactor" or "change" the code base.
-user-invocable: true
-disable-model-invocation: false
-effort: xhigh
-allowed-tools:
-    - "Skill"
-    - "Agent"
-    - "Read"
----
-
-@${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
-
-<purpose name="ase-code-refactor">
-Refactor Source Code
-</purpose>
-
-<expand name="getopt"
-    arg1="ase-code-refactor"
-    arg2="--auto|-a --dry|-d --direct|-D --quick|-Q --next|-n=(none|DONE|EDIT|GRILL|PREFLIGHT|IMPLEMENT)...">
-    $ARGUMENTS
-</expand>
-
-<if condition="<getopt-option-quick/> is equal `true`">
-The `--quick`/`-Q` flag is a *shorthand alias*: set <getopt-option-auto/>
-to `true`, <getopt-option-dry/> to `true`, and <getopt-option-next/> to
-`IMPLEMENT,DELETE`. Do not output anything.
-</if>
-
-<objective>
-*Refactor* existing artifacts the following way:
-<request><getopt-arguments/></request>
-</objective>
-
-@${CLAUDE_SKILL_DIR}/../../meta/ase-format-task.md
-@${CLAUDE_SKILL_DIR}/../../meta/ase-tenets.md
-@${CLAUDE_SKILL_DIR}/../../meta/ase-common-code.md
-
-Procedure
----------
-
-<if condition="<getopt-option-direct/> is not equal to 'true'">
-You *MUST* *NOT* call `Edit`, `Write`, `NotebookEdit`, or any
-filesystem-modifying tool, nor execute any filesystem-modifying
-shell command, during this entire skill. The *only* permitted way
-to persist artifacts is via the `ase_task_save(...)` MCP tool.
-</if>
-<else>
-The `--direct`/`-D` mode applies the refactoring *in place*, so STEP 4
-below *requires* `Edit` and `Write` to modify the affected artifacts.
-Every modification *MUST* still stay restricted to the artifacts the
-refactoring actually demands, and you *MUST* *NOT* call
-`ase_task_save(...)`, as no task plan is composed at all.
-</else>
-
-<flow>
-
-1.  <step id="STEP 1: Reason About Refactoring">
-
-    1.  <if condition="
-            <request/> matches the regexp `^[a-zA-Z][a-zA-Z0-9_-]*$`
-        ">
-        Set <ase-task-id><request/></ase-task-id> (set task id to request)
-        and <request></request> (set request empty), call the
-        `ase_task_id(id: "<ase-task-id/>", session: "<ase-session-id/>")` tool
-        from the `ase` MCP server to switch the task, and then only
-        output the following <template/>:
-
-        <template>
-        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **task given**
-        </template>
-        </if>
-
-    2.  <if condition="
-            <request/> has the format `<id/>: <text/>` AND
-            <id/> matches the regexp `^[a-zA-Z][a-zA-Z0-9_-]*$`
-        ">
-        Set <request><text/></request> and
-        <ase-task-id><id/></ase-task-id> and call the `ase_task_id(id:
-        "<ase-task-id/>", session: "<ase-session-id/>")` tool from the
-        `ase` MCP server to implicitly switch the task. Do not output
-        anything.
-        </if>
-
-    3.  <if condition="<request/> is empty">
-        Ask the user interactively, without a special tool, for the
-        initial request with a single question:
-
-        `**No refactoring details known yet. What is the refactoring you want to request?**`
-
-        Then set <request/> to the response of the user.
-        </if>
-
-    4.  <if condition="
-            <ase-task-id/> is equal `default` and
-            <request/> is not empty
-        ">
-        Set <ase-task-id/> to a unique task id, derived from <request/>,
-        which consists of two lower-case words concatenated with a
-        `-` character. Then call the `ase_task_id(id: "<ase-task-id/>",
-        session: "<ase-session-id/>")` tool from the `ase` MCP server to
-        implicitly switch the task. Do not output anything.
-        </if>
-
-    5.  Report the task and request with the following <template/>:
-
-        <template>
-        ⧉ **ASE**: ◉ task: **<ase-task-id/>**
-        ⧉ **ASE**: ⇌ request: **<request/>**
-        </template>
-
-    6.  Figure out what the artifact refactoring <request/> is about.
-
-    7.  Ask the user for clarification if the goal of this refactoring is
-        too unclear.
-
-    8.  Do not output anything else in this step, unless you asked the user.
-
-    </step>
-
-2.  <step id="STEP 2: Investigate Code Base">
-
-    1.  Check the existing source files for all code which is related to the
-        refactoring <request/>.
-
-    2.  Check the architecture of the existing code base to understand the
-        overall structures and dynamics.
-
-    3.  Do not output anything in this STEP 2.
-
-    </step>
-
-3.  <step id="STEP 3: Internalize Refactoring Tenets">
-
-    1.  <task-kind>REFACTORING</task-kind>
-
-    2.  <expand name="code-tenets" arg1="<task-kind/>"></expand>
-
-    3.  Do not output anything in this STEP 3.
-
-    </step>
-
-4.  <if condition="<getopt-option-direct/> is equal to 'true'">
-
-    <step id="STEP 4: Direct Refactoring">
-
-    1.  Directly apply the refactoring <request/> by modifying the
-        affected *artifacts* with a corresponding, complete *change set*,
-        based on your gathered knowledge about the code base and your
-        internalized refactoring tenets. Also, if a CHANGELOG.md
-        file exists, make an appropriate entry there, too.
-
-    2.  Output only the following <template/>:
-
-        <template>
-        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **changes directly applied**
-        </template>
-
-    3.  Then *IMMEDIATELY* *STOP* all further skill processing. You
-        *MUST* *NOT* output anything else in this STEP 4 or after it --
-        *independent* of <ase-project-boxing/>, whose exposure rules
-        are explicitly *overridden* here. Especially, do not output a
-        change summary, a list of modified artifacts, a rationale, or
-        a unified diff of the changes.
-
-    </step>
-
-    </if>
-    <else>
-
-    <step id="STEP 4: Choose Refactoring Approaches">
-
-    <expand name="code-approaches" arg1="refactoring" arg2="refactoring"></expand>
-
-    </step>
-
-    <step id="STEP 5: Compose Refactoring Plan">
-
-    1.  *Compose a refactoring plan* for the chosen refactoring A<n/> by
-        closely aligning to the existing architecture and the existing
-        code base. Use the <format/> defined for a task plan and inject
-        the information from refactoring A<n/> and all derived realization
-        decisions into it. Store the resulting task plan in <task-content/>.
-
-        If a `CHANGELOG.md` file exists in the project (or in any
-        affected sub-package), the plan *MUST* include, as part of its
-        `##  CHANGES` section, an explicit bullet point describing
-        the addition of a corresponding new entry to that `CHANGELOG.md`
-        file, aligned with its existing style and conventions.
-
-        <if condition="<getopt-option-dry/> is equal `true`">
-        You *MUST* completely omit the `##  VERIFICATION` section
-        (including its heading and all of its bullet points) from
-        <task-content/>.
-        </if>
-
-        You *MUST* *NOT* call `Edit`, `Write`, `NotebookEdit`, or any
-        filesystem-modifying tool during this step.
-
-    2.  Call the `ase_timestamp(format: "yyyy-LL-dd HH:mm")` tool of the
-        `ase` MCP server and use the `text` field of its response for
-        <timestamp-created/> and <timestamp-modified/> information. Then
-        insert the current <ase-task-id/>, <timestamp-created/>,
-        <timestamp-modified/>, and <task-kind/> information.
-
-    3.  You then *MUST* *save* the resulting plan content with the
-        `ase_task_save(id: "<ase-task-id/>", text: "<task-content/>")`
-        MCP tool call only -- *NEVER* by executing a shell command.
-
-    4.  Output a hint with the following <template/>:
-
-        <template>
-        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan created**
-        </template>
-
-    5.  Directly pass through control to the next skill:
-
-        <expand name="code-next-dispatch"></expand>
-
-    </step>
-
-    </else>
-
-</flow>
-