@rse/ase 1.0.7 → 2.0.1

package/plugin/skills/ase-repo-merge/help.md

@@ -0,0 +1,107 @@
+##  NAME
+
+`ase-repo-merge` - Merge a Branch
+
+##  SYNOPSIS
+
+`ase-repo-merge`
+    [`--help`|`-h`]
+    [`--target`|`-t` *branch*]
+    [`--mode`|`-m` `merge`|`rebase`|`squash`]
+    [`--cleanup`|`-c`]
+    *source-branch*
+
+##  DESCRIPTION
+
+The `ase-repo-merge` skill *merges* a Git *source-branch* into a target
+branch and reports the result as a *merge verdict*: `MERGED`,
+`CONFLICT`, or `FAILED`.
+
+Still *uncommitted* changes in the worktree where the source branch is
+checked out are first *committed* with a derived one-line commit
+message of the form `<type>: <summary>`. The source branch is then
+merged inside the worktree where the target branch is checked out,
+which has to be free of uncommitted changes, in one of three modes: a
+regular *merge* with a merge commit (`git merge --no-ff`), a *rebase*
+of the source branch onto the target branch followed by a
+fast-forward (`git rebase` plus `git merge --ff-only`), or a *squash*
+of all source commits into one commit (`git merge --squash`).
+Merge conflicts are *resolved semantically*, honoring the intents of
+both sides and never losing any change, through the same procedure as
+`ase-repo-resolve`. If a conflict is unresolvable, because both
+intents contradict each other or no confident resolution exists, the
+unresolvable conflicts are reported, the merge is *aborted*, the
+target branch is left untouched, and the verdict is `CONFLICT`. Finally, the skill *checks*
+that the source branch is contained in the target branch. It does
+*not* build or test the merge result, so semantically resolved
+conflicts still deserve a review.
+
+On a `CONFLICT` or `FAILED` verdict, the commit of the previously
+uncommitted source changes is *undone* again, so they are uncommitted
+as before (but no longer partially staged).
+
+If the source branch *equals* the target branch, only its uncommitted
+changes are committed. The skill is also used by `ase agent integrator`
+to drive the *Integration* phase of the `enterprise` task lifecycle
+model headless. As the target branch is by default the checked-out
+branch of the working copy of the project, any uncommitted change
+there lets the merge of every task with its own branch fail, and hence
+the task become `DEFERRED`, while for a task with an in-place change
+set it is committed together with that change set. So, when running
+the integrator, keep the working copy clean and do your own work in
+separate worktrees.
+
+##  OPTIONS
+
+-   `--target`|`-t` *branch*:
+    The target branch of the merge (default: `current`, the checked-out
+    branch of the working copy).
+
+-   `--mode`|`-m` `merge`|`rebase`|`squash`:
+    The merge mode (default: `merge`): `merge` creates a merge commit,
+    `rebase` rebases the source branch (rewriting its commits, in its
+    own worktree if it is checked out) onto the target branch and
+    fast-forwards the target branch, and `squash` combines all changes
+    of the source branch into one new commit on the target branch.
+    Conflicts are resolved per rebased commit under `rebase`.
+
+-   `--cleanup`|`-c`:
+    After a successful merge, remove the worktree of the source branch
+    (if any) and delete the merged source branch.
+
+##  ARGUMENTS
+
+-   *source-branch*:
+    The Git branch to merge.
+
+##  SCENARIOS
+
+-   You want a feature branch landed on the checked-out branch
+-   You want the uncommitted result of a worktree committed and merged
+-   You want merge conflicts resolved instead of hand-editing them
+
+##  EXAMPLES
+
+Merge the branch `feature-x` into the checked-out branch:
+
+```text
+❯ /ase-repo-merge feature-x
+```
+
+Merge the branch `feature-x` into `develop` and remove it afterwards:
+
+```text
+❯ /ase-repo-merge --target develop --cleanup feature-x
+```
+
+Squash the branch `feature-x` into one commit on the checked-out branch:
+
+```text
+❯ /ase-repo-merge --mode squash feature-x
+```
+
+##  SEE ALSO
+
+[`ase-task-implement`](../ase-task-implement/help.md), [`ase-repo-resolve`](../ase-repo-resolve/help.md), [`ase-repo-review`](../ase-repo-review/help.md),
+[`ase-repo-commit`](../ase-repo-commit/help.md), [`ase-repo-dissect`](../ase-repo-dissect/help.md).
+

package/plugin/skills/ase-repo-resolve/SKILL.md

@@ -0,0 +1,158 @@
+---
+name: ase-repo-resolve
+argument-hint: "[--help|-h] [--dir|-d <dir>] [--safe|-s] [--interactive|-i] [<path> ...]"
+description: >
+    Resolve the Git merge conflicts of a working directory -- of an
+    in-progress merge, rebase, cherry-pick, revert, stash apply, or of
+    conflict markers left by patch -- carefully and semantically, never
+    losing any change, escalate unresolvable hunks as-is, continue the
+    in-progress operation, and emit a RESOLVED, PARTIAL, NONE, or FAILED
+    verdict. Use when the user calls to "resolve" or "fix" merge
+    conflicts.
+user-invocable: true
+disable-model-invocation: false
+effort: high
+allowed-tools:
+    - "Bash(git *)"
+    - "Bash(mkdir -p *)"
+    - "Bash(cp -p *)"
+    - "Bash(rm -rf *)"
+    - "Read"
+    - "Edit"
+    - "Write"
+---
+
+@${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-repo-resolve">
+Resolve Merge Conflicts
+</purpose>
+
+<expand name="getopt"
+    arg1="ase-repo-resolve"
+    arg2="--dir|-d=. --safe|-s --interactive|-i">
+    $ARGUMENTS
+</expand>
+
+<objective>
+*Resolve* the merge conflicts of the working directory *semantically*,
+*never* losing any change, *escalate* the unresolvable hunks as-is,
+*continue* the in-progress operation, and report the *resolve verdict*.
+</objective>
+
+@${CLAUDE_SKILL_DIR}/../../meta/ase-common-resolve.md
+
+Procedure
+---------
+
+<flow>
+
+1.  <step id="STEP 1: Resolve Conflicts">
+
+    1.  Set <paths/> to <getopt-arguments/> with any leading and
+        trailing whitespace stripped. Do not output anything.
+
+    2.  Resolve the conflicts by expanding the following:
+
+        <expand name="resolve-conflicts"
+            arg1="ase-repo-resolve"
+            arg2="<getopt-option-dir/>"
+            arg3="<getopt-option-interactive/>"
+            arg4="<getopt-option-safe/>"
+            arg5="<paths/>"></expand>
+
+    3.  <if condition="<resolve-verdict/> is `FAILED`">
+        Only output the following <template/> and then immediately
+        *STOP* processing the entire current skill:
+
+        <template>
+        ⧉ **ASE**: ✪ skill: **ase-repo-resolve**, ▶ ERROR: **<getopt-option-dir/>** is no Git working directory, ▶ RESOLVE VERDICT: **FAILED**
+        </template>
+        </if>
+        <elseif condition="<resolve-verdict/> is `NONE`">
+        Only output the following <template/> and then immediately
+        *STOP* processing the entire current skill:
+
+        <template>
+        ⧉ **ASE**: ✪ skill: **ase-repo-resolve**, ⎇ operation: **<resolve-operation/>**, ▶ RESOLVE VERDICT: **NONE**
+        </template>
+        </elseif>
+
+    </step>
+
+2.  <step id="STEP 2: Continue Operation">
+
+    1.  If <resolve-verdict/> is not `RESOLVED` or <resolve-operation/>
+        is `none`, skip this entire STEP 2, as either conflicts remain
+        or there is no operation to continue (e.g., after
+        `git stash apply` or `patch --merge`).
+
+    2.  Run the command
+        `git -C "<repo-root/>" diff --name-only --diff-filter=U`. If its
+        output is *not* empty (unmerged files outside of <paths/>
+        remain), only output the following <template/> and skip the
+        remaining items of this STEP 2:
+
+        <template>
+        ⧉ **ASE**: ✪ skill: **ase-repo-resolve**, ⎇ operation: **<resolve-operation/>**, ▶ status: **not continued -- further conflicted files remain**
+        </template>
+
+    3.  Continue the operation by running the command
+        `git -C "<repo-root/>" -c core.editor=true <resolve-operation/> --continue`,
+        which keeps the prepared commit message without opening an
+        editor.
+
+        <if condition="the command stopped again with new conflicts (only possible for a `rebase`, `cherry-pick`, or `revert` of multiple commits)">
+        Only output the following <template/> and then *START OVER* at
+        STEP 1, item 2, to resolve the conflicts of the next commit:
+
+        <template>
+        ⧉ **ASE**: ✪ skill: **ase-repo-resolve**, ⎇ operation: **<resolve-operation/>**, ▶ status: **continued -- next conflicts**
+        </template>
+        </if>
+        <elseif condition="the command failed for another reason">
+        Only output the following <template/>, as the resolution itself
+        is complete and staged:
+
+        <template>
+        ⧉ **ASE**: ✪ skill: **ase-repo-resolve**, ⎇ operation: **<resolve-operation/>**, ▶ WARNING: operation failed to continue
+        </template>
+        </elseif>
+        <else>
+        Only output the following <template/>:
+
+        <template>
+        ⧉ **ASE**: ✪ skill: **ase-repo-resolve**, ⎇ operation: **<resolve-operation/>**, ▶ status: **operation continued**
+        </template>
+        </else>
+
+    </step>
+
+3.  <step id="STEP 3: Report Verdict">
+
+    1.  Report the escalations by expanding the following:
+
+        <expand name="resolve-report" arg1="ase-repo-resolve"></expand>
+
+    2.  Only output the following <template/>:
+
+        <template>
+        ⧉ **ASE**: ✪ skill: **ase-repo-resolve**, ⎇ operation: **<resolve-operation/>**, ▶ RESOLVE VERDICT: **<resolve-verdict/>**
+        </template>
+
+    3.  <if condition="<resolve-verdict/> is `PARTIAL`">
+        Give the closing hint by expanding the following (which,
+        depending on the configured <ase-guidance-level/>, may expand
+        into nothing and hence emit no output at all):
+
+        <ase-tpl-hint level="minimal">
+        Resolve the escalated hunks manually (or re-run with `--interactive`), stage the files via `git add`, and continue the operation.
+        </ase-tpl-hint>
+        </if>
+
+    </step>
+
+</flow>

package/plugin/skills/ase-repo-resolve/help.md

@@ -0,0 +1,102 @@
+
+##  NAME
+
+`ase-repo-resolve` - Resolve Merge Conflicts
+
+##  SYNOPSIS
+
+`ase-repo-resolve`
+    [`--help`|`-h`]
+    [`--dir`|`-d` *dir*]
+    [`--safe`|`-s`]
+    [`--interactive`|`-i`]
+    [*path* ...]
+
+##  DESCRIPTION
+
+The `ase-repo-resolve` skill *resolves* the Git merge conflicts of a
+working directory and reports the result as a *resolve verdict*:
+`RESOLVED`, `PARTIAL`, `NONE`, or `FAILED`.
+
+It handles every *unmerged* state of the Git index -- left by an
+in-progress `git merge`, `git rebase`, `git cherry-pick`, `git revert`,
+or by `git stash apply` -- and additionally files carrying conflict
+markers *without* an unmerged index entry, e.g., left by `patch
+--merge`. Reject files (`*.rej`) of `patch` are escalated, but never
+touched.
+
+Every conflict hunk is resolved *semantically*: the intents of both
+sides are determined from the commits, the base version, and the
+surrounding code, and the hunk is resolved so that *both* intents are
+honored. Trivial, independent, and compatible changes are combined,
+while a hunk whose intents *contradict* each other, or for which no
+confident resolution exists, is *kept as-is* including its conflict
+markers and *escalated* to the user. Files with only some unresolvable
+hunks are resolved *partially* and stay unmerged. Non-content conflicts
+(binary, submodule, modify/delete, rename, delete/delete) are resolved
+only if their intent is unambiguous.
+
+The skill is very careful to *never lose* any change: every touched
+file is first backed up into the `ase-resolve` directory inside the Git
+directory, and every resolved hunk is checked to still reflect all
+changes of both sides relative to the base; a hunk failing this check
+is restored with its conflict markers and escalated. The backups are
+removed on a `RESOLVED` verdict and kept otherwise.
+
+Fully resolved unmerged files are staged. On a `RESOLVED` verdict, the
+in-progress operation is *continued* (e.g., `git merge --continue`),
+and, if this stops at the next conflicting commit of a rebase,
+cherry-pick, or revert, those conflicts are resolved, too. The skill
+does *not* build or test the result, so the resolved conflicts still
+deserve a review.
+
+The same resolution procedure is used by `ase-repo-merge` for the
+conflicts of its merge.
+
+##  OPTIONS
+
+-   `--dir`|`-d` *dir*:
+    The Git working directory whose conflicts are resolved (default:
+    `.`, the current working directory).
+
+-   `--safe`|`-s`:
+    Never touch non-content conflicts (binary, submodule,
+    modify/delete, rename, delete/delete), but always escalate them.
+
+-   `--interactive`|`-i`:
+    Instead of directly escalating an unresolvable hunk, show it and
+    let the user choose `OURS`, `THEIRS`, `BOTH`, `KEEP` (escalate), or
+    describe a manual resolution. Ignored when running headless.
+
+##  ARGUMENTS
+
+-   *path* ...:
+    Restrict the resolution to the conflicted files equal to or below
+    the given paths. The in-progress operation is then continued only
+    if no conflicted files remain elsewhere.
+
+##  SCENARIOS
+
+-   You ran into merge conflicts during a merge, rebase, or cherry-pick
+-   You applied a stash or a patch and got conflict markers
+-   You want conflicts resolved without risking the loss of any change
+
+##  EXAMPLES
+
+Resolve all conflicts of the current working directory:
+
+```text
+❯ /ase-repo-resolve
+```
+
+Resolve the conflicts below `src/`, deciding unresolvable hunks
+interactively:
+
+```text
+❯ /ase-repo-resolve --interactive src/
+```
+
+##  SEE ALSO
+
+[`ase-repo-merge`](../ase-repo-merge/help.md), [`ase-repo-review`](../ase-repo-review/help.md),
+[`ase-repo-commit`](../ase-repo-commit/help.md), [`ase-repo-diff`](../ase-repo-diff/help.md).