@rse/ase 0.0.30 → 0.0.32

package/plugin/skills/ase-meta-search/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: ase-meta-search
+argument-hint: "<query>"
+description: >
+    Search the Internet/Web with a query.
+    Prefer this skill before using Perplexity, Brave and WebSearch.
+user-invocable: true
+disable-model-invocation: false
+effort: low
+allowed-tools:
+    - "mcp__perplexity__perplexity_search"
+    - "mcp__brave__brave_web_search"
+    - "WebSearch"
+    - "WebFetch"
+    - "Task"
+---
+
+@${CLAUDE_SKILL_DIR}/../../meta/ase-persona.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+
+Search the Internet/Web
+=======================
+
+Your role is an expert-level *web specialist*.
+
+<objective>
+Your objective is to *search* the *Internet*/*Web* for the following query:
+<query>$ARGUMENTS</query>
+</objective>
+
+<flow>
+1.  <step id="STEP 1: QUERY SERVICES">
+    If the MCP tool `mcp__perplexity__perplexity_search` is available, send <query/> to it
+    via a first *sub-task* and our companion `ase-meta-search` *agent*.
+
+    If the MCP tool `mcp__brave__brave_web_search` is available, send <query/> to it
+    via a second *sub-task* and our companion `ase-meta-search` *agent*.
+
+    Send <query/> to the built-in tool `WebSearch`
+    via a third *sub-task* and our companion `ase-meta-search` *agent*.
+    </step>
+
+2.  <step id="STEP 2: CONSOLIDATE ANSWERS">
+    Consolidate all responses from the `ase-meta-search` *agents*
+    into a single response and output it without giving any further explanations.
+    </step>
+</flow>
+

package/plugin/skills/ase-meta-why/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: ase-meta-why
+argument-hint: "<fact>"
+description: >
+    Five-Whys Root-Cause Analysis.
+user-invocable: true
+disable-model-invocation: false
+effort: medium
+---
+
+@${CLAUDE_SKILL_DIR}/../../meta/ase-persona.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+
+Five-Whys Root-Cause Analysis
+=============================
+
+Your role is an *expert-level assistant*.
+
+<objective>
+Apply the *Five-Whys* *root-cause analysis* technique to investigate
+on the following problem:
+
+<problem>Why $ARGUMENTS?</problem>
+
+For this, iteratively ask "why" to drill down from symptoms to the root-cause.
+This helps to identify the fundamental reason behind a problem rather than just
+addressing surface-level symptoms.
+</objective>
+
+<flow>
+1.  <step id="STEP 1: PROBLEM">
+    State the problem statement.
+
+    <template>
+    &#x1F7E0; **PROBLEM**: <problem/>
+    </template>
+    </step>
+
+2.  <step id="STEP 2: ROOT-CAUSE ANALYSIS">
+    Find the root-cause of <problem/> by following the following iteration cycle.
+    Start with a <question/> equal to the <problem/>.
+
+    <for items="1 2 3 4 5">
+        Ask <question/> and document the <answer/> with the following template:
+        Don't stop at symptoms, keep digging for systemic issues.
+        Multiple root-causes may exist -- explore different branches.
+        Consider both technical, domain-specific, process-related or organizational causes.
+
+        <template>
+        &#x26AA; **WHY <item/>**: <answer/>
+        </template>
+
+        Then, for the next iteration let <question/> now be the last <answer/>.
+        The magic is NOT in exactly 5 "Why" -- you can <break/> the iteration
+        when you already reached the root-cause.
+    </for>
+    </step>
+
+3.  <step id="STEP 3: SOLUTION">
+    Validate the root-cause by working backwards the causality chain.
+    Propose a solution that addresses and solves the root-cause.
+    For the proposed solution, optionally directly propose corresponding source code changes.
+
+    <template>
+    &#x1F7E0; **SOLUTION**: <solution/>
+    </template>
+    </step>
+</flow>
+

package/plugin/skills/ase-task-delete/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: ase-task-delete
+argument-hint: "[<id>]"
+description: >
+    Delete the current or given task plan.
+    Use when the user calls to "delete", "remove" or "clear" the
+    "task", "plan", "spec", or "specification".
+user-invocable: true
+disable-model-invocation: false
+effort: low
+---
+
+@${CLAUDE_SKILL_DIR}/../../meta/ase-persona.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+
+Delete a Task Plan
+==================
+
+<skill name="ase-task-delete">
+Delete a Task Plan
+</skill>
+
+Your role is an experienced, *expert-level assistant*.
+*Delete* the task plan.
+
+Procedure
+---------
+
+You *MUST* follow the following numbered items *strictly* *sequentially*!
+You *MUST* not skip any numbered item during processing!
+
+You *MUST* *NOT* output anything in this entire procedure, *except* when
+explicitly requested by this procedure via outputs based on a <template/>!
+
+1.  **Determine Task:**
+
+    1.  Set <id>$ARGUMENTS</id> initially.
+        Inherit the always existing <ase-task-id/> from the current context.
+        Do not output anything.
+
+    2.  <if condition="<id/> is empty">
+        Set <id><ase-task-id/></id>
+        Do not output anything.
+        </if>
+
+2.  **Perform Operation**:
+
+    1.  Call the `task_delete(id: <id/>)` tool of the `ase` MCP
+        service to delete the task plan content and set <text/> to the
+        `text` output field of this `task_delete` tool call. Do not
+        output anything related to this MCP tool call.
+
+        -   If <text/> starts with `ERROR:` or `WARNING:`:
+            Only output the following <template/>:
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<id/>**, ▶ status: **<text/>**
+            </template>
+
+        -   If <text/> starts NOT with `ERROR:`:
+            Only output the following <template/>:
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<id/>**, ▶ status: **task deleted**
+            </template>
+
+    2.  <if condition="<id/> is equal <ase-task-id/> AND <ase-task-id/> is not equal 'default'">
+        Set <ase-task-id>default</ase-task-id>. Call the `task_id(id:
+        <ase-task-id/>, session: <ase-session-id/>)` tool from the `ase`
+        MCP service to switch the task to the default task. Only output
+        the following <template/>:
+
+        <template>
+        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **task switched to default**
+        </template>
+        </if>

package/plugin/skills/ase-task-edit/SKILL.md

@@ -0,0 +1,390 @@
+---
+name: ase-task-edit
+argument-hint: "[<id> | <id>: <instruction> | <instruction>]"
+description: >
+    Iteratively edit and refine a named plan for a task through a
+    conversational loop. Each round, the current plan is shown and the
+    user is asked whether to keep refining, mark the plan as done, or
+    proceed to the implementation or preflight. Use when the user wants
+    to plan a task purely through chat-driven refinement.
+user-invocable: true
+disable-model-invocation: false
+effort: high
+---
+
+@${CLAUDE_SKILL_DIR}/../../meta/ase-persona.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-dialog.md
+
+Iteratively Edit a Task Plan
+============================
+
+<skill name="ase-task-edit">
+Iteratively Edit a Task Plan
+</skill>
+
+Your role is an experienced, *expert-level assistant*,
+specialized in the *planning* of changes
+through *iterative conversational refinement*.
+
+Establish and refine the *task plan* purely through a *chat-driven
+loop*. The user steers each round via interactive dialog that offers
+continued refinement, finalization, or hand-off to implementation or
+preflight.
+
+@${CLAUDE_SKILL_DIR}/../../meta/ase-plan.md
+
+Procedure
+---------
+
+You *MUST* follow the following numbered items *strictly* *sequentially*!
+You *MUST* not skip any numbered item during processing!
+
+You *MUST* *NOT* output anything in this entire procedure, *except* when
+explicitly requested by this procedure via outputs based on a <template/>!
+
+1.  **Determine Task and Instruction:**
+
+    1.  Set <instruction>$ARGUMENTS</instruction> initially.
+        Inherit the always existing <ase-task-id/> from the current context.
+        Do not output anything.
+
+    2.  React on task and/or instruction:
+
+        1.  <if condition="
+                <instruction/> matches the regexp `^[a-zA-Z][a-zA-Z0-9_-]*$`
+            ">
+            Set <ase-task-id><instruction/></ase-task-id> (set task
+            id to instruction) and <instruction></instruction> (set
+            instruction empty), call the `task_id(id: <ase-task-id/>,
+            session: <ase-session-id/>)` tool from the `ase` MCP
+            service to switch the task, and then only output the
+            following <template/>:
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **task given**
+            </template>
+            </if>
+
+        2.  else <if condition="
+                <instruction/> has the format `<id/>: <text/>` where
+                <id/> matches the regexp `^[a-zA-Z][a-zA-Z0-9_-]*$` and
+                <text/> is *empty*
+            ">
+            Set <instruction></instruction> (set instruction to empty)
+            and <ase-task-id><id/></ase-task-id> (set task id to
+            id) and call the `task_id(id: <ase-task-id/>, session:
+            <ase-session-id/>)` tool from the `ase` MCP service to
+            switch the task, and then only output the following
+            <template/>:
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **task given**
+            </template>
+            </if>
+
+        3.  else <if condition="
+                <instruction/> has the format `<id/>: <text/>` where
+                <id/> matches the regexp `^[a-zA-Z][a-zA-Z0-9_-]*$` and
+                <text/> is *not empty*
+            ">
+            Set <instruction><text/></instruction> (set instruction to
+            text) and <ase-task-id><id/></ase-task-id> (set task id
+            to id) and call the `task_id(id: <ase-task-id/>, session:
+            <ase-session-id/>)` tool from the `ase` MCP service to
+            switch the task, and then only output the following
+            <template/>:
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **task given**
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ⇌ instruction: **<instruction/>**, ▶ status: **instruction given**
+            </template>
+            </if>
+
+        4.  else <if condition="
+                <instruction/> is not empty
+            ">
+            Only output the following <template/>:
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **task inherited**
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ⇌ instruction: **<instruction/>**, ▶ status: **instruction given**
+            </template>
+            </if>
+
+        5.  else <if condition="
+                <instruction/> is empty
+            ">
+            Only output the following <template/>:
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **task inherited**
+            </template>
+            </if>
+
+2.  **Determine Plan:**
+
+    1.  Call the `task_load(id: <ase-task-id/>)` tool of the `ase` MCP
+        service to load any existing plan content and set <text/> to
+        the `text` output field of this `task_load` tool call.
+        Do not output anything related to this MCP tool call.
+        Set <content-dirty>false</content-dirty>.
+
+        -   If <text/> starts with `ERROR:`:
+            Silently ignore the MCP error.
+            Set <content/> to empty.
+            Set <words/> to "0".
+            Do not output anything.
+
+        -   If <text/> starts NOT with `ERROR:`:
+            Set <content><text/></content> (set content to text).
+            Calculate the number of words <words/> of <content/>.
+            Only output the following <template/>:
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan loaded**
+            </template>
+
+    2.  <if condition="<content/> is empty AND <instruction/> is empty">
+        Ask the user interactively, without a special tool, for the
+        initial plan content with a single question:
+
+        `**No plan content yet. What is the task you want to plan?**`
+
+        Then set <instruction/> to the response of the user and only
+        output the following <template/>:
+
+        <template>
+        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ⇌ instruction: **<instruction/>**, ▶ status: **instruction given**
+        </template>
+        </if>
+
+    3.  <if condition="<content/> is not empty AND
+            <instruction/> is not empty AND
+            <instruction/> is not equal <content/>">
+        Let the *user interactively choose* what to do as the next step.
+
+        <expand name="user-dialog>
+        Previous Plan: Should the previous plan content be overwritten, refined, or preserved?
+        OVERWRITE: Continue operation, overwrite previous plan.
+        REFINE: Continue operation, refine previous plan.
+        PRESERVE: Cancel operation, preserve previous plan.
+        </expand>
+
+        Check the tool <result/> and dispatch accordingly:
+
+        -   If <result/> is `CANCEL` or `PRESERVE`:
+
+            Only output the following <template/> and then immediately
+            *STOP* processing this skill:
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan preserved**
+            </template>
+
+        -   If <result/> is `OVERWRITE`:
+
+            Create a new plan from scratch and store the result as
+            <content/> by closely following the defined plan format
+            <format/> and injecting into it all the information from
+            the <instruction/> and all decisions you derived from the
+            <instruction/>.
+
+            Call the `timestamp(format: "yyyy-LL-dd HH:mm")` tool of the
+            `ase` MCP service and use the `text` field of its response
+            for fresh <timestamp-created/> and <timestamp-modified/>
+            information. Then insert the current <ase-task-id/>,
+            <timestamp-created/>, and <timestamp-modified/> information
+            and calculate the number of words <words/> of <content/>.
+            Set <content-dirty>true</content-dirty>.
+
+            Only output the following <template/> and continue processing:
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan overwritten**
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ⇌ instruction: **<instruction/>**, ▶ status: **instruction given**
+            </template>
+
+        -   If <result/> is `REFINE`:
+
+            Treat the <instruction/> as a *refinement instruction* for
+            the plan, and update <content/> in-place by *applying* the
+            requested <instruction/> to the *plan*. When refining the
+            plan this way, preserve the overall structure of the plan
+            and only modify what the user actually requested. Do *not*
+            rewrite unrelated sections of the plan.
+
+            Calculate the number of words <words/> of <content/>.
+            Set <content-dirty>true</content-dirty>.
+
+            Only output the following <template/> and continue processing:
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan refined**
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ⇌ instruction: **<instruction/>**, ▶ status: **instruction given**
+            </template>
+        </if>
+
+    4.  <if condition="<content/> does not contain '# ✪ TASK PLAN:' AND <instruction/> is empty">
+        Set <instruction><content/></instruction> (set instruction to content).
+        Set <content></content> (set content to empty).
+        Set <content-dirty>true</content-dirty>.
+        Do not output anything.
+        </if>
+
+    5.  <if condition="<content/> is empty AND <instruction/> is not empty">
+        Create a new plan from scratch and store the result as
+        <content/> by closely following the defined plan format
+        <format/> and injecting into it all the information from
+        the <instruction/> and all decisions you derived from the
+        <instruction/>.
+
+        Call the `timestamp(format: "yyyy-LL-dd HH:mm")` tool of the
+        `ase` MCP service and use the `text` field of its response
+        for fresh <timestamp-created/> and <timestamp-modified/>
+        information. Then insert the current <ase-task-id/>,
+        <timestamp-created/>, and <timestamp-modified/> information
+        and calculate the number of words <words/> of <content/>.
+        Set <content-dirty>true</content-dirty>.
+
+        Only output the following <template/> and continue processing:
+
+        <template>
+        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ⇌ instruction: **<instruction/>**, ▶ status: **instruction given**
+        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan generated**
+        </template>
+        </if>
+
+3.  **Iterative Plan Refinement Loop:**
+
+    *REPEAT* the following steps 3.1 to 3.4 in a *LOOP* until
+    the user selects `DONE`, `IMPLEMENT`, or `PREFLIGHT`, or
+    declines/cancels in the dialog of step 3.4:
+
+    1.  *Update timestamp*:
+        <if condition="<content/> contains '✎ modified:' AND <content-dirty/> is 'true'">
+        Set update <timestamp-modified/> with the current time in
+        ISO-style format, which has to be determined by calling the
+        `timestamp(format: "yyyy-LL-dd HH:mm")` tool of the `ase`
+        MCP service and use the `text` field of its response. Update
+        <content/> with the new `✎ modified: **<timestamp-modified/>**`.
+        Do not output anything.
+        </if>
+
+    2.  *Persist plan*:
+        <if condition="<content-dirty/> is 'true'">
+        Call the `task_save(id: <ase-task-id/>, text: <content/>)` tool
+        of the `ase` MCP service to persist the current plan, and then
+        set <content-dirty>false</content-dirty> again. Calculate the
+        number of words <words/> of <content/>. Do not output anything
+        related to this MCP tool call except the following <template/>:
+
+        <template>
+        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan saved**
+        </template>
+        </if>
+
+    3.  *Render plan*: Only output the following <template/>, so the user
+        can read the plan and react to it. Do *not* truncate, summarize,
+        or partially show the plan -- always show the complete plan
+        <content/> here:.
+
+        <template>
+        ⧉ **ASE**: ┈┈┈┈┈┈┈┈────────━━━━━━━━**(** `TASK-PLAN-BEGIN` **)**━━━━━━━━────────┈┈┈┈┈┈┈┈
+        <content/>
+        ⧉ **ASE**: ┈┈┈┈┈┈┈┈────────━━━━━━━━**(**  `TASK-PLAN-END`  **)**━━━━━━━━────────┈┈┈┈┈┈┈┈
+        </template>
+
+    4.  *Ask user*: Let the *user interactively choose* what to do as the
+        next step.
+
+        <expand name="user-dialog>
+        Next Step: How would you like to proceed with the plan?
+        DONE: Mark plan finalized, exit planning loop.
+        IMPLEMENT: Hand off plan to implementation.
+        PREFLIGHT: Hand off plan to pre-flighting.
+        REFINE: Further refine plan with instructions.
+        </expand>
+
+        Check the tool <result/> and dispatch accordingly:
+
+        -   If <result/> is `DONE`:
+
+            *Break* out of the *loop*, only output the following <template/>
+            and then *STOP*. Do *not* implement the plan.
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan finalized -- done**
+            </template>
+
+        -   If <result/> is `IMPLEMENT`:
+
+            *Break* out of the *loop*, only output the following
+            <template/> and then use the `Skill` tool to invoke the
+            `ase:ase-task-implement` skill in order to *apply* the finalized
+            plan.
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan finalized -- hand-off to implementation**
+            </template>
+
+        -   If <result/> is `PREFLIGHT`:
+
+            *Break* out of the *loop*, only output the following
+            <template/> and then use the `Skill` tool to invoke the
+            `ase:ase-task-preflight` skill in order to *apply* the finalized
+            plan.
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan finalized -- hand-off to pre-flight**
+            </template>
+
+        -   If <result/> is `REFINE`:
+
+            Ask the user interactively, without a special tool, for
+            the refinement instruction with a single question `**What
+            is your instruction for refining the plan?**`. Then set
+            <instruction/> to the response of the user.
+
+            Treat the <instruction/> as a *refinement instruction* for
+            the plan, and update <content/> in-place by *applying* the
+            requested <instruction/> to the *plan*. When refining the
+            plan this way, preserve the overall structure of the plan
+            and only modify what the user actually requested. Do *not*
+            rewrite unrelated sections of the plan.
+            Set <content-dirty>true</content-dirty>.
+
+            Finally, only output the following <template/> and then
+            *continue* the *loop* at step **3.1**!
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ⇌ instruction: **<instruction/>**, ▶ status: **plan refined**
+            </template>
+
+        -   If <result/> matches `OTHER: <text/>`:
+
+            Set <instruction><text/></instruction>.
+
+            Treat the <instruction/> as a *refinement instruction* for
+            the plan, and update <content/> in-place by *applying* the
+            requested <instruction/> to the *plan*. When refining the
+            plan this way, preserve the overall structure of the plan
+            and only modify what the user actually requested. Do *not*
+            rewrite unrelated sections of the plan.
+            Set <content-dirty>true</content-dirty>.
+
+            Finally, only output the following <template/> and then
+            *continue* the *loop* at step **3.1**!
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ⇌ instruction: **<instruction/>**, ▶ status: **plan refined**
+            </template>
+
+        -   If <result/> is `CANCEL`:
+
+            *Break* out of the *loop*, only output the following <template/>
+            and then *STOP*. Do *not* implement the plan.
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan refinement cancelled**
+            </template>

package/plugin/skills/ase-task-id/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: ase-task-id
+argument-hint: "[<id>]"
+description: >
+    Get or set unique task id <id>.
+    Use when user requests to work on a certain task
+    or wants to know what the current task is.
+user-invocable: true
+disable-model-invocation: false
+effort: low
+---
+
+@${CLAUDE_SKILL_DIR}/../../meta/ase-persona.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+
+Task Configuration
+==================
+
+<skill name="ase-task-id">
+Configure Task Id
+</skill>
+
+1.  Determine request:
+    <request>$ARGUMENTS</request>
+
+2.  <if condition="<request/> is empty">
+    -   Call the `task_id(session: <ase-session-id/>)`
+        tool from the `ase` MCP service and set
+        <ase-task-id/> to its `text` output.
+
+    -   Output:
+        <template>
+        ⧉ **ASE**: ◉ task: **<ase-task-id/>**
+        </template>
+    </if>
+
+3.  <if condition="<request/> is NOT empty">
+    -   Set <ase-task-id><request/></ase-task-id> and
+        call the `task_id(id: <ase-task-id/>, session: <ase-session-id/>)`
+        tool from the `ase` MCP service.
+
+    -   Output:
+        <template>
+        ⧉ **ASE**: ◉ task: **<ase-task-id/>** (*updated*)
+        </template>
+    </if>