@rse/ase 0.0.30 → 0.0.31

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>

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

@@ -0,0 +1,146 @@
+---
+name: ase-task-implement
+argument-hint: "[<id>]"
+description: >
+    Implement current or given task plan.
+    Use when the user calls to "implement", "realize" or "apply" the
+    "task", "plan", "spec", or "specification".
+user-invocable: true
+disable-model-invocation: false
+effort: xhigh
+---
+
+@${CLAUDE_SKILL_DIR}/../../meta/ase-persona.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-dialog.md
+
+Implement a Task Plan
+=====================
+
+<skill name="ase-task-implement">
+Implement a Task Plan
+</skill>
+
+Your role is an experienced, *expert-level assistant*,
+specialized in the *implementation* of changes.
+
+*Implement* the task plan by modifying the *artifacts*
+with a corresponding, complete *change set*.
+
+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 <instruction>$ARGUMENTS</instruction> initially.
+        Inherit the always existing <ase-task-id/> from the current context.
+        Inherit the always existing <ase-session-id/> from the current context.
+        Do not output anything.
+
+    2.  React on task id:
+
+        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>
+
+2.  **Determine Operation**:
+
+    1.  Call the `task_load(id: <ase-task-id/>)` tool of the `ase` MCP
+        service to load the current task plan content and set <content/> to
+        the `text` output field of the `task_load` tool call.
+
+        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 the <content/> is still empty, complain and tell the user to
+        use the `ase-code-resolve`, `ase-code-refactor`, `ase-code-craft`,
+        or `ase-task-edit` skills first to create a task plan.
+
+3.  **Create Implementation:**
+
+    1.  Perform a *final implementation* of the task plan
+        by modifying the *artifacts* with a corresponding, complete
+        *change set*.
+
+        For this, primarily follow and honor the task plan in <content/>.
+
+        Secondarily, derive hints from the optionally existing
+        `IMPLEMENTATION DRAFT` section (from skill `ase-task-preflight`)
+        in <content/>. But the specification text in <content/> always
+        overrules the implementation draft in the `IMPLEMENTATION DRAFT`
+        section of <content/>.
+
+    2.  Only output the following <template/>:
+
+        <template>
+        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan implemented**
+        </template>
+
+4.  **Decide Next Step:**
+
+    1.  *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: Stop processing and PRESERVE task plan.
+        DELETE: Stop processing and DELETE the task plan.
+        </expand>
+
+    2.  Check the tool <result/> and dispatch accordingly:
+
+        -   If <result/> is `DONE` or `CANCEL`:
+            Only output the following <template/> and then *STOP*.
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan implemented -- done**
+            </template>
+
+        -   If <result/> is `DELETE`:
+            Only output the following <template/> and then use the
+            `Skill` tool to invoke the `ase:ase-task-delete` skill in
+            order to *implement* the updated plan. Immediately stop
+            processing the current skill once the `Skill` tool was used.
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan implemented -- hand-off to delete task**
+            </template>

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

@@ -0,0 +1,44 @@
+---
+name: ase-task-list
+argument-hint: ""
+description: >
+    List all available task ids.
+    Use when user wants to see all tasks.
+user-invocable: true
+disable-model-invocation: false
+effort: low
+---
+
+@${CLAUDE_SKILL_DIR}/../../meta/ase-persona.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+
+Task List
+=========
+
+<skill name="ase-task-list">
+List Task Plans
+</skill>
+
+1.  Call the `task_list({ verbose: true })` tool from the `ase` MCP service.
+    The result is a structured object with a `tasks` array where each
+    entry has an `id` field and an `mtime` field (formatted as
+    `YYYY-MM-DD HH:MM`).
+
+2.  If the `tasks` array is empty, output the following <template/>:
+
+    <template>
+    ⧉ **ASE**: ◉ tasks: *(none)*
+    </template>
+
+    Else, output the list of tasks with the following <template/>, where
+    each <id/> and <mtime/> correspond to an entry in the task list:
+
+    <template>
+    ⧉ **ASE**: ◉ tasks:
+
+    | *Task Id* | *Last Modified*    |
+    |-----------|--------------------|
+    | **<id/>** | `<mtime/>`         |
+    | [...]     | [...]              |
+    </template>
+