@corners/cli 0.0.5 → 0.0.7

package/skills/corners-ask/SKILL.md

@@ -0,0 +1,223 @@
+---
+name: corners-ask
+version: 0.1.0
+description: |
+  Post a durable question to a workstream for team input.
+  Offers structured templates and auto-generates rationale from code context.
+allowed-tools:
+  - Bash
+  - Read
+  - AskUserQuestion
+---
+
+# /corners-ask — "I need the team's input"
+
+Post a well-structured question to your workstream. The question is visible to the
+whole team in corner chat. When they answer, skill continuation can auto-resume
+your work if configured.
+
+---
+
+## Step 0: Preamble
+
+Run these commands to check auth and resolve context:
+
+```bash
+corners auth status --json 2>/dev/null || echo "CORNERS_CLI_MISSING"
+```
+
+```bash
+corners workstream current --json 2>/dev/null
+```
+
+```bash
+_BRANCH=$(git branch --show-current 2>/dev/null || echo "unknown")
+echo "BRANCH: $_BRANCH"
+```
+
+**Error handling — check in this order:**
+
+1. If `CORNERS_CLI_MISSING` or `command not found`: tell user to install (`npm install -g @corners/cli`) and **STOP**.
+2. If `loggedIn=false` OR `remoteValid=false`: tell user to run `corners auth login` and **STOP**.
+3. If `resolvedCorner` is null: tell user to run `corners corner use <id>` and **STOP**.
+4. If `connectedWorkstreamIds` is empty: tell user to run `/corners-sync` first and **STOP**.
+
+Use the first connected workstream ID for all subsequent steps.
+
+---
+
+## Step 1: Gather Code Context
+
+Run:
+
+```bash
+git diff --stat 2>/dev/null | head -10
+```
+
+```bash
+git log --oneline -5 2>/dev/null
+```
+
+Note the current branch, recently modified files, and recent commit messages.
+This context will be used to auto-generate the question's rationale.
+
+---
+
+## Step 2: Choose Question Template
+
+Use AskUserQuestion:
+- Re-ground: "Workstream question on branch {branch}."
+- Question: "What kind of question do you need to ask the team?"
+- Options:
+  - **A) Architecture decision** — "We need to choose between technical approaches. I'll help you frame the options and tradeoffs."
+  - **B) Scope clarification** — "Something might be in or out of scope. I'll help you ask clearly."
+  - **C) Blocker escalation** — "You're blocked and need someone to unblock you. I'll help frame the urgency."
+  - **D) Freeform** — "Custom question — I'll help you sharpen it."
+
+Note the selected template for Step 3.
+
+---
+
+## Step 3: Formulate the Question
+
+Based on the selected template, guide the user through formulation.
+
+### Template A: Architecture Decision
+
+Use AskUserQuestion:
+- Question: "What's the technical decision you're facing? Describe the options you see."
+- Options: freeform text
+
+Then draft the question in this structure:
+```
+We need to decide: {user's decision}
+
+Options:
+A) {option 1} — {tradeoff}
+B) {option 2} — {tradeoff}
+C) {option 3 if applicable}
+
+Context: Currently working on branch {branch}. Recent changes: {summary from git context}.
+```
+
+### Template B: Scope Clarification
+
+Use AskUserQuestion:
+- Question: "What's the scope question? What might be in or out?"
+- Options: freeform text
+
+Draft:
+```
+Scope question: {user's question}
+
+Current context: Working on {branch}. This came up while {brief context from git}.
+If in scope: {implication}
+If out of scope: {implication}
+```
+
+### Template C: Blocker Escalation
+
+Use AskUserQuestion:
+- Question: "What are you blocked on? Who or what can unblock you?"
+- Options: freeform text
+
+Draft:
+```
+Blocked: {user's blocker description}
+
+Impact: {what can't proceed until this is resolved}
+Needed from: {person or team if known}
+Branch: {branch}
+```
+
+### Template D: Freeform
+
+Use AskUserQuestion:
+- Question: "What do you want to ask the team?"
+- Options: freeform text
+
+Use the user's text directly.
+
+---
+
+## Step 4: Refine and Confirm
+
+Present the drafted question to the user via AskUserQuestion:
+- Show the full question text
+- Show the auto-generated rationale (derived from git context: "This question arose while
+  working on branch {branch}, which modifies {files}. Recent commits: {summary}.")
+- Show 2-3 suggested answers (derived from the template — for architecture decisions,
+  the options become suggested answers; for scope, "In scope" / "Out of scope" / "Defer";
+  for blockers, "I can help" / "Escalate to {person}" / "Deprioritize")
+- Options: "Post as-is" / "Edit question" / "Edit rationale" / "Cancel"
+
+If the user wants to edit, use AskUserQuestion for the specific field and re-present.
+
+---
+
+## Step 5: Post the Question
+
+Post via heredoc for shell safety:
+
+```bash
+corners workstream question ask <workstreamId> \
+  --question "$(cat <<'CORNERS_MSG'
+<final question text>
+CORNERS_MSG
+)" \
+  --rationale "$(cat <<'CORNERS_MSG'
+<final rationale text>
+CORNERS_MSG
+)" \
+  --suggested-answer "<answer 1>" \
+  --suggested-answer "<answer 2>" \
+  --json
+```
+
+Parse the response to confirm success and extract the question ID.
+
+---
+
+## Step 6: Blocker Follow-up (Template C only)
+
+If the user selected "Blocker escalation" in Step 2, also push a blocker update:
+
+```bash
+corners workstream push <workstreamId> --type blocker --message "$(cat <<'CORNERS_MSG'
+<brief blocker description from the question>
+CORNERS_MSG
+)" --json
+```
+
+---
+
+## Step 7: Confirm
+
+Display:
+
+```
+Posted question to workstream {name} ({id}):
+  "{first 80 chars of question}..."
+  Suggested answers: {list}
+  {If blocker also posted: "Also posted blocker update."}
+
+The team will see this in corner chat.
+When they answer, skill continuation will auto-resume if configured.
+```
+
+---
+
+## Manual Equivalent
+
+```bash
+# Post a question
+corners workstream question ask <wsId> \
+  --question "What should we do about X?" \
+  --rationale "This came up while working on Y" \
+  --suggested-answer "Option A" \
+  --suggested-answer "Option B" \
+  --json
+
+# Also post a blocker (if applicable)
+corners workstream push <wsId> --type blocker --message "Blocked on X" --json
+```

package/skills/corners-plan/SKILL.md

@@ -0,0 +1,253 @@
+---
+name: corners-plan
+version: 0.1.0
+description: |
+  Create a plan collaboratively, write it to docs/plans/, and post
+  summary and open questions to the workstream for team alignment.
+allowed-tools:
+  - Bash
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+  - AskUserQuestion
+---
+
+# /corners-plan — "How should we approach this?"
+
+Collaboratively create a plan, write it to `docs/plans/`, post a summary to the
+workstream, and surface open questions for the team. The plan document lives in
+git; the coordination lives on the workstream.
+
+---
+
+## Step 0: Preamble
+
+Run these commands to check auth and resolve context:
+
+```bash
+corners auth status --json 2>/dev/null || echo "CORNERS_CLI_MISSING"
+```
+
+```bash
+corners workstream current --json 2>/dev/null
+```
+
+```bash
+_BRANCH=$(git branch --show-current 2>/dev/null || echo "unknown")
+echo "BRANCH: $_BRANCH"
+```
+
+**Error handling — check in this order:**
+
+1. If `CORNERS_CLI_MISSING` or `command not found`: tell user to install (`npm install -g @corners/cli`) and **STOP**.
+2. If `loggedIn=false` OR `remoteValid=false`: tell user to run `corners auth login` and **STOP**.
+3. If `resolvedCorner` is null: tell user to run `corners corner use <id>` and **STOP**.
+4. If `connectedWorkstreamIds` is empty: proceed to Step 1 (workstream creation wizard).
+   If connected, skip to Step 2 using the first connected workstream ID.
+
+---
+
+## Step 1: Workstream Creation Wizard (only if no workstream connected)
+
+First, check if any workstreams exist:
+
+```bash
+corners workstream list --json 2>/dev/null
+```
+
+**If workstreams exist:** Normalize the current branch name (strip `feat/`, `fix/`, etc.,
+replace hyphens with spaces, title-case). Compare against workstream names.
+
+If a match is found, use AskUserQuestion:
+- Question: "Found workstream '{name}'. Connect it for this plan?"
+- Options: "Yes" / "No, create a new one"
+
+If no match, or if the user wants a new one, proceed to creation.
+
+**If no workstreams exist, or user wants to create one:**
+
+Derive a name from the current branch:
+- `feat/auth-refactor` → "Auth Refactor"
+- `fix/login-bug` → "Login Bug"
+- `main` → use the plan topic (ask in Step 2)
+
+Use AskUserQuestion:
+- Question: "Create workstream '{derived name}' for this plan?"
+- Options: "Yes, create it" / "Use a different name" / "Skip workstream — just write the plan locally"
+
+If creating:
+```bash
+corners workstream create "<name>" --json
+```
+
+Extract the workstream ID from the response, then connect it:
+```bash
+corners workstream use <id> --json
+```
+
+If "Skip workstream": proceed with plan creation but skip Steps 5 and 6 (no workstream posting).
+
+---
+
+## Step 2: Pull Existing Context
+
+If a workstream is connected, pull its context:
+
+```bash
+corners workstream pull <workstreamId> --json 2>/dev/null
+```
+
+Also check for existing plans:
+
+```bash
+ls docs/plans/ 2>/dev/null
+```
+
+Note any existing plans, prior discussions, threads, and questions from the workstream.
+This context informs the planning conversation.
+
+---
+
+## Step 3: Interactive Planning
+
+Guide the user through a structured planning conversation. Use AskUserQuestion for
+each step. Adapt based on the user's responses — skip steps that aren't relevant.
+
+**3a. Problem definition:**
+- Question: "What problem are we solving? What's the goal?"
+- Options: freeform text
+
+**3b. Constraints and context:**
+- Question: "What constraints should we keep in mind? (timeline, tech stack, dependencies, team)"
+- Options: freeform text / "No special constraints"
+
+**3c. Options and tradeoffs:**
+- Question: "What approaches have you considered? I can also suggest some based on the codebase."
+- Options: freeform text / "Suggest approaches for me"
+If "Suggest approaches": read relevant code files based on the problem description
+and propose 2-3 approaches with tradeoffs.
+
+**3d. Recommended approach:**
+Based on the discussion, propose a recommended approach.
+- Question: "Here's my recommended approach: {description}. Does this look right?"
+- Options: "Yes, use this" / "Modify it" / "Let's discuss more"
+
+**3e. Open questions:**
+- Question: "Are there decisions that need team input before we can proceed?"
+- Options: freeform text / "No open questions"
+Capture each open question for Step 6.
+
+---
+
+## Step 4: Write Plan Document
+
+Check if `docs/plans/` exists. If not, create it.
+
+Derive a slug from the plan topic (lowercase, hyphens, no special chars).
+
+Write the plan to `docs/plans/<slug>.md`:
+
+```markdown
+# {Plan Title}
+
+**Status:** Draft
+**Created:** {date}
+**Workstream:** {name} ({id}) — or "None" if skipped
+
+## Problem
+
+{From Step 3a}
+
+## Constraints
+
+{From Step 3b}
+
+## Options Considered
+
+{From Step 3c — list each option with tradeoffs}
+
+## Recommended Approach
+
+{From Step 3d}
+
+## Open Questions
+
+{From Step 3e — numbered list}
+
+## Implementation Notes
+
+{Any technical details gathered during the conversation}
+```
+
+Tell the user: "Plan written to `docs/plans/{slug}.md`"
+
+---
+
+## Step 5: Post Summary to Workstream (skip if no workstream)
+
+Post a concise summary of the plan:
+
+```bash
+corners workstream push <workstreamId> --type status --message "$(cat <<'CORNERS_MSG'
+Plan: {title}. {1-2 sentence summary of the recommended approach}. Plan document at docs/plans/{slug}.md.
+CORNERS_MSG
+)" --json
+```
+
+---
+
+## Step 6: Post Open Questions (skip if no workstream or no questions)
+
+For each open question identified in Step 3e, post it to the workstream:
+
+```bash
+corners workstream question ask <workstreamId> \
+  --question "$(cat <<'CORNERS_MSG'
+<question text>
+CORNERS_MSG
+)" \
+  --rationale "$(cat <<'CORNERS_MSG'
+This question came up during planning for: {plan title}. See docs/plans/{slug}.md for full context.
+CORNERS_MSG
+)" \
+  --json
+```
+
+---
+
+## Step 7: Confirm
+
+Display:
+
+```
+Plan created:
+  File: docs/plans/{slug}.md
+  {If workstream: "Workstream: {name} ({id})"}
+  {If summary posted: "Summary posted to workstream feed"}
+  {If questions posted: "{N} open questions posted to corner chat"}
+  {If no workstream: "No workstream connected — plan is local only"}
+
+{If questions posted:}
+The team will see the open questions in corner chat.
+When they answer, you can refine the plan.
+```
+
+---
+
+## Manual Equivalent
+
+```bash
+# Create a workstream
+corners workstream create "My Feature" --json
+
+# Connect it
+corners workstream use <wsId>
+
+# Post a plan summary
+corners workstream push <wsId> --type status --message "Plan: ..." --json
+
+# Post an open question
+corners workstream question ask <wsId> --question "..." --rationale "..." --json
+```

package/skills/corners-push/SKILL.md

@@ -0,0 +1,177 @@
+---
+name: corners-push
+version: 0.1.0
+description: |
+  Record progress, learnings, blockers, or outcomes to a workstream.
+  Auto-drafts from git state and asks for confirmation before posting.
+allowed-tools:
+  - Bash
+  - Read
+  - AskUserQuestion
+---
+
+# /corners-push — "Here's what I did / learned / hit"
+
+Analyze your recent git activity, draft a progress update, and post it to your
+connected workstream. The team sees this in corner chat.
+
+---
+
+## Step 0: Preamble
+
+Run these commands to check auth and resolve context:
+
+```bash
+corners auth status --json 2>/dev/null || echo "CORNERS_CLI_MISSING"
+```
+
+```bash
+corners workstream current --json 2>/dev/null
+```
+
+```bash
+_BRANCH=$(git branch --show-current 2>/dev/null || echo "unknown")
+echo "BRANCH: $_BRANCH"
+```
+
+**Error handling — check in this order:**
+
+1. If the first command printed `CORNERS_CLI_MISSING` or `command not found`: tell the user
+   "Corners CLI is not installed. Run `npm install -g @corners/cli` to install it." and **STOP**.
+
+2. Parse the auth status JSON. If `loggedIn` is `false` OR `remoteValid` is `false`:
+   tell the user "Your Corners session has expired. Run `corners auth login` to re-authenticate." and **STOP**.
+
+3. Parse the workstream current JSON. If `resolvedCorner` is null:
+   tell the user "No corner is configured. Run `corners corner use <cornerId>`." and **STOP**.
+
+4. Check `connectedWorkstreamIds`. If empty:
+   tell the user "No workstream connected. Run `/corners-sync` first to connect one." and **STOP**.
+
+Use the first connected workstream ID for all subsequent steps.
+
+---
+
+## Step 1: Analyze Git State
+
+Run:
+
+```bash
+git log origin/main..HEAD --oneline 2>/dev/null
+```
+
+```bash
+git diff --stat 2>/dev/null | tail -5
+```
+
+Parse the output:
+- Count the number of commits since the base branch
+- Note the files changed and their scope
+
+**If no commits exist** (the git log is empty or the branch is main with no divergence):
+Use AskUserQuestion:
+- Question: "No new commits found since origin/main. Want to write a manual update instead?"
+- Options: "Yes, write a manual update" / "Cancel"
+If "Cancel", **STOP**.
+If "Yes", skip to Step 3 with no auto-draft — ask the user to type the update.
+
+---
+
+## Step 2: Classify Update Type
+
+Based on the git context, determine the update type. If the type is clear from context
+(e.g., all commits are `fix:` → outcome, a commit says "WIP" → status), set it directly.
+
+If ambiguous, use AskUserQuestion:
+- Re-ground: "Workstream update on branch {branch}. You have {N} commits since origin/main."
+- Question: "What kind of update is this?"
+- Options:
+  - **A) Status** — "Progress update: here's what I've done and what remains"
+  - **B) Learning** — "I discovered something the team should know"
+  - **C) Outcome** — "Work is complete, here's the result"
+  - **D) Blocker** — "I'm stuck and need help or a decision"
+
+Note the selected type for Step 4.
+
+---
+
+## Step 3: Draft the Update
+
+Auto-generate a 2-5 sentence summary of the work done. Base it on:
+- The commit messages from `git log`
+- The files changed from `git diff --stat`
+- The update type selected in Step 2
+
+Write the draft in plain language as if explaining to a teammate who hasn't seen the code.
+Focus on WHAT was accomplished and WHY, not implementation details.
+
+Present the draft via AskUserQuestion:
+- Re-ground: "Workstream update on branch {branch}, type: {type}."
+- Question: "Here's the auto-drafted update. Edit or approve?"
+- Show the draft text
+- Options: "Post as-is" / "Let me edit it"
+
+If "Let me edit it": use AskUserQuestion with a freeform text option for the user
+to provide their edited version.
+
+---
+
+## Step 4: Post the Update
+
+Post the update using the heredoc pattern for shell safety:
+
+```bash
+corners workstream push <workstreamId> --type <type> --message "$(cat <<'CORNERS_MSG'
+<final message text>
+CORNERS_MSG
+)" --json
+```
+
+Parse the response to confirm success.
+
+---
+
+## Step 5: Detect and Attach Artifacts
+
+Check for an open PR:
+
+```bash
+gh pr view --json url,title,number 2>/dev/null
+```
+
+If a PR exists, use AskUserQuestion:
+- Question: "Found open PR #{number}: '{title}'. Attach it to the workstream?"
+- Options: "Yes, attach" / "No, skip"
+
+If "Yes": note the attachment. (The CLI `corners workstream attach` command can
+link PRs if supported, otherwise mention the PR URL in the update.)
+
+---
+
+## Step 6: Confirm
+
+Display a confirmation:
+
+```
+Posted to workstream {name} ({id}):
+  Type: {type}
+  Message: "{first 100 chars of message}..."
+  {If PR attached: "Attached PR: #{number}"}
+
+The team will see this in corner chat.
+```
+
+---
+
+## Manual Equivalent
+
+```bash
+# See what you've done
+git log origin/main..HEAD --oneline
+
+# Post an update
+corners workstream push <wsId> --type status --message "..." --json
+
+# Check for open PR
+gh pr view --json url
+```