@corners/cli 0.0.4 → 0.0.6

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
+```

package/skills/corners-sync/SKILL.md

@@ -0,0 +1,245 @@
+---
+name: corners-sync
+version: 0.1.0
+description: |
+  Pull workstream context and present a structured briefing.
+  Shows recent activity, open questions, and suggested next actions.
+  Offers to answer open questions inline and writes context to memory.
+allowed-tools:
+  - Bash
+  - Read
+  - Write
+  - AskUserQuestion
+---
+
+# /corners-sync — "Get me up to speed"
+
+Pull context from your connected workstream, present a structured briefing,
+answer open questions inline, and write key context to memory for future sessions.
+
+---
+
+## 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"
+git log --oneline -5 2>/dev/null
+git status --short 2>/dev/null | head -10
+```
+
+**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 or missing:
+   tell the user "No corner is configured for this directory. Run `corners corner use <cornerId>` to set one up." and **STOP**.
+
+4. Check `connectedWorkstreamIds` in the workstream current JSON.
+   If the array is empty, proceed to Step 1 (workstream resolution).
+   If it has entries, skip to Step 2 using the first connected workstream ID.
+
+---
+
+## Step 1: Workstream Resolution (only if no workstream connected)
+
+Run:
+```bash
+corners workstream list --json 2>/dev/null
+```
+
+Parse the response. There are three scenarios:
+
+**Scenario A — Workstreams exist:**
+Normalize the current git branch name: strip common prefixes (`feat/`, `fix/`, `chore/`, `refactor/`),
+replace hyphens and underscores with spaces, and title-case the result.
+Compare this normalized name against the `name` field of each workstream in the list.
+
+If a workstream name is similar to the normalized branch name, use AskUserQuestion:
+- Question: "Found workstream '{name}' which seems related to your branch '{branch}'. Connect it?"
+- Options: "Yes, connect it" / "No, show me all workstreams" / "Create a new one instead"
+
+If "Yes": run `corners workstream use <id> --json` and proceed to Step 2.
+If "Show all": present the full list via AskUserQuestion and let the user pick.
+If "Create new": proceed to Scenario C.
+
+If no workstream name matches the branch, present the full list via AskUserQuestion
+and let the user pick one, or offer to create a new one.
+
+**Scenario B — No workstreams exist anywhere:**
+Use AskUserQuestion:
+- Question: "No workstreams exist yet. Create one to start tracking your work?"
+- Derive a suggested name from the current branch (e.g., `feat/auth-refactor` → "Auth Refactor")
+- Options: "Yes, create '{suggested name}'" / "Yes, with a different name" / "Skip — just show git context"
+
+If creating: run `corners workstream create "{name}" --json`, then `corners workstream use <returned id> --json`.
+
+**Scenario C — Create new:**
+Derive name from branch, confirm with user, run create + use.
+
+After resolution, proceed to Step 2 with the workstream ID.
+
+---
+
+## Step 2: Pull Workstream Context
+
+Run these commands to gather full context:
+
+```bash
+corners workstream pull <workstreamId> --json 2>/dev/null
+```
+
+```bash
+corners workstream question list <workstreamId> --json 2>/dev/null
+```
+
+Parse the JSON responses. Extract:
+- From pull: `workstream.id`, `workstream.name`, `workstream.summary`, `workstream.status`,
+  `threads[]`, `feedEvents[]`, `attachments[]`
+- From question list: `questions[]` with fields `id`, `questionText`, `rationale`,
+  `suggestedAnswers[]`, `askedBy`, `status`, `createdAt`
+
+If `feedEvents` or `threads` has more than 10 items, use only the most recent 10
+and note the total count.
+
+---
+
+## Step 3: Present Structured Briefing
+
+Display the briefing in this format:
+
+```
+## Workstream: {name} ({id})
+Status: {status}
+Summary: {summary}
+
+### Recent Activity
+{Summarize the last 10 feed events in 1-2 lines each. Include type, timestamp, and key content.}
+
+### Open Questions ({count})
+{For each open question:}
+- **{askedBy}** ({timeAgo}): "{questionText}"
+  Suggested answers: {list suggestedAnswers}
+
+### Threads ({count})
+{For each thread, show topic/subject and message count}
+
+### Attachments ({count})
+{List any linked documents, files, or artifacts}
+
+### Local Git State
+Branch: {branch}
+Recent commits: {list from git log}
+Working tree: {clean / N files modified}
+
+### Suggested Next Actions
+{Based on the context, suggest 2-3 concrete next steps. Examples:}
+- Answer Alice's question about the API schema
+- Review the latest thread about deployment
+- Continue work on the auth-refactor branch
+```
+
+---
+
+## Step 4: Answer-at-Sync
+
+After presenting the briefing, check if any open questions exist.
+
+For each open question (up to 3), use AskUserQuestion:
+- Re-ground: "Workstream '{name}' on branch {branch}."
+- Question: "{askedBy} asked: '{questionText}'"
+- If suggested answers exist, include them as options plus "Skip" and "Custom answer"
+- If no suggested answers, options: "Answer now" / "Skip"
+
+If the user provides an answer, post it:
+```bash
+corners workstream question answer <questionId> --text "$(cat <<'CORNERS_MSG'
+<user's answer text>
+CORNERS_MSG
+)" --json
+```
+
+If the user skips, move to the next question or proceed to Step 5.
+
+---
+
+## Step 5: Memory Write
+
+Write workstream context to Claude Code's memory system so it persists across conversations.
+
+Determine the memory directory path. It follows the pattern:
+`~/.claude/projects/-{path-with-hyphens}/memory/`
+
+For this project, the path is derived from the working directory. Use the memory
+directory that already exists for this project.
+
+Write a memory file named `workstream_{normalized_name}.md` (lowercase, hyphens for spaces):
+
+```markdown
+---
+name: Workstream context - {name}
+description: Active workstream {name} ({id}) - {summary}
+type: project
+---
+
+Connected workstream for this repository.
+
+- **ID:** {id}
+- **Name:** {name}
+- **Status:** {status}
+- **Summary:** {summary}
+
+**Open questions ({count}):**
+{For each: "- {askedBy}: {questionText}" — keep to 1 line each}
+
+**Recent activity:**
+{2-3 sentence summary of what's been happening}
+
+**How to apply:** When working in this repo, this workstream provides the coordination context. Check for open questions before starting new work. Use /corners-push to record progress.
+```
+
+Then read the existing `MEMORY.md` file in the same directory. If a reference to this
+workstream memory file doesn't already exist, add it under the `## Project` section.
+
+---
+
+## Manual Equivalent
+
+The raw CLI commands this skill orchestrates:
+
+```bash
+# Check auth
+corners auth status --json
+
+# Resolve local context
+corners workstream current --json
+
+# List available workstreams
+corners workstream list --json
+
+# Connect a workstream
+corners workstream use <wsId>
+
+# Pull full context
+corners workstream pull <wsId> --json
+
+# List open questions
+corners workstream question list <wsId> --json
+
+# Answer a question
+corners workstream question answer <questionId> --text "..." --json
+```