@dabble/linear-cli 1.0.1 → 1.0.3

package/claude/commands/done.md

@@ -15,11 +15,11 @@ Help the developer wrap up their work on the current Linear issue.
 2. **Summarize the work** by checking:
    - `git log --oneline <base>..HEAD` to see commits
    - `git diff --stat <base>..HEAD` to see files changed
-3. **Ask what they want to do** using AskUserQuestion:
-   - Close the issue in Linear
-   - Create a PR first
-   - Add final notes to the issue
-   - Just clean up (worktree only)
+3. **Ask what they want to do:**
+   - Create PR and close
+   - Close issue (no PR)
+   - Add notes and close
+   - Just clean up (keep issue open)
 
 ## After Selection
 
@@ -50,11 +50,7 @@ You've made 3 commits on ISSUE-12: Add caching layer
 - src/cache.ts (new file, 45 lines)
 - src/api.ts (modified, +12 -3)
 
-What would you like to do?
-1. Create PR and close issue
-2. Close issue (no PR)
-3. Add notes and close
-4. Just clean up worktree (don't close)
+[Presents options above]
 ```
 
 ## Notes

package/claude/commands/next.md

@@ -21,47 +21,11 @@ Skip straight to starting work on that issue (see "Starting Work on an Issue" be
 
 ### Presenting Options
 
-Always present a numbered list with these rules:
-- Show up to **5 issues maximum** (yours are already sorted first by the CLI)
-- If more than 5 issues exist, note how many more after the list
-- **Always** include "Product planning" as the final option
-
-### Format
-
-```
-Here's what's ready to work on:
-
-1. ISSUE-5: Add caching layer [Backlog] (assigned to you)
-2. ISSUE-8: Fix login timeout [Backlog]
-3. ISSUE-12: Update API docs [Backlog]
-4. ISSUE-18: Do Something Else [Backlog]
-5. ISSUE-29: Another thing [Backlog]
-   ... and 7 more unblocked issues
-6. Product planning - brainstorm features, review backlog, plan next phase
-
-Which would you like to work on?
-```
-
-### If NO unblocked issues:
-
-```
-No unblocked issues at the moment.
-
-1. Product planning - brainstorm features, review backlog, plan next phase
-
-Would you like to work on product planning?
-```
-
-### If exactly ONE issue:
-
-```
-There's one issue ready to work on:
-
-1. ISSUE-5: Add caching layer [Backlog] (assigned to you)
-2. Product planning - brainstorm features, review backlog, plan next phase
-
-Which would you like?
-```
+Present interactive options:
+- Up to **3 issues** (CLI already sorts yours first)
+- **Always** include "Product planning" as an option
+- If >3 issues, note how many more
+- User can always type a specific issue ID
 
 ## Starting Work on an Issue
 
@@ -70,25 +34,19 @@ When the user selects an issue (or provides one directly via `/next ISSUE-12`):
 1. Run `linear issue start <id>` to assign and set In Progress
 2. Run `linear branch <id>` to create a git branch
 3. Run `linear issue show <id>` to display full context
-4. **Enter plan mode** using the EnterPlanMode tool
-
-This ensures every issue starts with a proper implementation plan before writing code.
+4. **Enter plan mode** to explore the codebase and design an implementation approach
 
 ## If they choose "Product planning"
 
-Start a planning session by asking:
-
-"What would you like to focus on?"
-- Review and prioritize the backlog
+Ask what they want to focus on:
+- Review and prioritize backlog
 - Brainstorm new features
 - Plan the next phase
-- Something specific
 
-Then follow the product-planning skill guidelines to facilitate the session.
+Then follow the product-planning skill guidelines.
 
 ## Notes
 
 - Always use long flags (--unblocked, not -u) for clarity
 - The CLI already sorts your assigned issues first
-- If presenting options, use the AskUserQuestion tool for a clean interface
 - The "Product planning" option ensures there's always something productive to do

package/claude/commands/standup.md

@@ -24,10 +24,10 @@ Run `linear standup` to get:
 ## After Running
 
 1. Present the output from `linear standup` to the user
-2. Offer to help with:
-   - Drafting a standup message for Slack/Teams
-   - Identifying what to work on next (suggest `/next`)
-   - Resolving any blockers
+2. Ask what they want to do next:
+   - Draft standup message (for Slack/Teams)
+   - Find next issue (run /next)
+   - Resolve blockers
 
 ## Example Flow
 
@@ -52,7 +52,7 @@ Here's your standup summary:
 - 4 commits on beautiful-tech
 - PR #42 merged: ISSUE-5: Add caching layer
 
-Would you like me to help draft a standup message, or shall we look at what to work on next?
+[Presents options above]
 ```
 
 ## Notes

package/claude/skills/{linear-cli.md → linear-cli/SKILL.md}

@@ -41,18 +41,26 @@ linear login                    # Interactive setup
 linear logout                   # Remove config
 linear whoami                   # Show current user/team
 
+# Roadmap (overview)
+linear roadmap                  # Projects with milestones and progress
+
 # Issues
 linear issues --unblocked       # Ready to work on (no blockers)
 linear issues --open            # All non-completed issues
+linear issues --backlog         # Backlog issues only
 linear issues --in-progress     # Issues currently in progress
 linear issues --mine            # Only your assigned issues
+linear issues --project "Name"  # Issues in a project
+linear issues --milestone "M1"  # Issues in a milestone
 linear issues --label bug       # Filter by label
 # Flags can be combined: linear issues --in-progress --mine
 linear issue show ISSUE-1        # Full details with parent context
 linear issue start ISSUE-1       # Assign to you + set In Progress
 linear issue create --title "Fix bug" --project "Phase 1" --assign --estimate M
+linear issue create --title "Task" --milestone "Beta" --estimate S
 linear issue create --title "Blocked task" --blocked-by ISSUE-1
 linear issue update ISSUE-1 --state "In Progress"
+linear issue update ISSUE-1 --milestone "Beta"
 linear issue update ISSUE-1 --append "Notes..."
 linear issue update ISSUE-1 --blocks ISSUE-2  # Add blocking relation
 linear issue close ISSUE-1
@@ -65,6 +73,19 @@ linear project show "Phase 1"   # Details with issues
 linear project create "Name" --description "..."
 linear project complete "Phase 1"
 
+# Milestones
+linear milestones --project "P1" # Milestones in a project
+linear milestone show "Beta"     # Details with issues
+linear milestone create "Beta" --project "P1" --target-date 2024-03-01
+
+# Reordering (drag-drop equivalent)
+linear projects reorder "P1" "P2" "P3"           # Set project order
+linear project move "Urgent" --before "Phase 1"  # Move single project
+linear milestones reorder "Alpha" "Beta" --project "P1"
+linear milestone move "Beta" --after "Alpha" --project "P1"
+linear issues reorder ISSUE-1 ISSUE-2 ISSUE-3    # Set issue order
+linear issue move ISSUE-5 --before ISSUE-1       # Move single issue
+
 # Labels
 linear labels                   # List all labels
 linear label create "bug" --color "#FF0000"
@@ -112,6 +133,13 @@ gh pr create --title "ISSUE-5: Add caching layer"
 
 ## Workflow Guidelines
 
+### Getting oriented
+```bash
+linear roadmap                  # See all projects, milestones, progress
+linear issues --project "P1"    # Issues in a specific project
+linear issues --milestone "M1"  # Issues in a specific milestone
+```
+
 ### Starting work on an issue
 ```bash
 linear issues --unblocked       # Find what's ready
@@ -163,6 +191,21 @@ linear issue update ISSUE-2 --append "## Notes\n\nDiscovered X, trying Y approac
 linear issue comment ISSUE-2 "Found the root cause in auth.ts:142"
 ```
 
+### Organizing with milestones
+Milestones group related issues within a project:
+
+```bash
+# Create milestone for a release
+linear milestone create "Beta" --project "Phase 1" --target-date 2024-03-01
+
+# Add issues to milestone
+linear issue create --title "Core feature" --milestone "Beta" --estimate M
+linear issue update ISSUE-5 --milestone "Beta"
+
+# Reorder milestones to reflect priority
+linear milestones reorder "Alpha" "Beta" "Stable" --project "Phase 1"
+```
+
 ### Completing a phase
 ```bash
 linear issue close ISSUE-7       # Close remaining issues

package/claude/skills/product-planning/SKILL.md

@@ -0,0 +1,108 @@
+---
+name: product-planning
+description: Facilitate product thinking and structure work in Linear.
+---
+
+# Product Planning
+
+Help users think through product ideas and structure them as actionable work in Linear.
+
+## Mindset
+
+- **Thought partner, not ticket factory** - Understand before creating issues
+- **Problem before solution** - What problem? For whom? How painful?
+- **Default to smaller** - Cut scope ruthlessly, defer the non-essential
+- **Incremental delivery** - Ship value early, learn, iterate
+
+## Style
+
+Like Jason Fried without swearing. Concise, simple wording. Short back-and-forth dialog over long answers. Casual.
+
+## Start: Gather Context
+
+```bash
+linear roadmap        # Projects, milestones, progress
+linear issues --open  # Active work
+```
+
+Read `product.md` if it exists—contains product vision, brand, tech decisions, prior planning context.
+
+## Process
+
+### 1. Explore the Problem
+
+Before solutions:
+- What problem? For whom? How painful?
+- What job is the user hiring this product/feature to do?
+- What happens if we don't solve it?
+- What constraints? (time, tech, dependencies)
+- What's uncertain or risky?
+
+Proactively search the web when exploring unfamiliar territory (competitors, market, technical approaches).
+
+### 2. Design the Solution
+
+- What approaches exist? Tradeoffs?
+- What's the riskiest assumption to test first?
+- What's the **simplest version** that delivers value?
+- What can wait for later?
+- How will users discover and use this? What's prominent vs. hidden?
+
+Cut scope aggressively—except for core/differentiating features where polish and detail set you apart.
+
+For technical work, explore the existing codebase first to understand patterns and architecture.
+
+### 3. Structure the Work
+
+**Sizing:** XS/S/M = single issue, < 1 day. L/XL = needs breakdown.
+
+```bash
+# Parent issue (the goal)
+linear issue create --title "User auth system" --estimate L --project "Phase 2"
+
+# Sub-issues (the steps)
+linear issue create --title "Design auth flow" --parent ISSUE-10 --estimate S
+linear issue create --title "Implement login" --parent ISSUE-10 --estimate M
+linear issue create --title "Add sessions" --parent ISSUE-10 --blocked-by ISSUE-11 --estimate M
+```
+
+### 4. Organize
+
+**Milestones** for phases within a project:
+```bash
+linear milestone create "Beta" --project "Phase 2" --target-date 2024-03-01
+linear issue create --title "Core feature" --milestone "Beta" --estimate M
+```
+
+**Dependencies** make `--unblocked` useful:
+```bash
+linear issue create --title "Need API credentials" --blocks ISSUE-5
+```
+
+### 5. Prioritize
+
+```bash
+linear projects reorder "Phase 1" "Phase 2" "Phase 3"
+linear milestones reorder "Alpha" "Beta" --project "Phase 2"
+linear issue move ISSUE-5 --before ISSUE-1
+```
+
+## Update product.md
+
+After planning, update `product.md` with any new or refined:
+- Product vision, problem statement, target users
+- Brand voice or positioning
+- Technical architecture decisions
+- Key decisions made and rationale
+- Deferred items and why
+
+Create the file if it doesn't exist. Keep it concise.
+
+## Session Summary
+
+Track progress throughout the session, then summarize:
+
+1. **Created** - Issues/milestones with IDs
+2. **Decided** - Key decisions and rationale
+3. **Deferred** - What we cut (and why)
+4. **Next** - `linear issues --unblocked`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dabble/linear-cli",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Linear CLI with unblocked issue filtering, built for AI-assisted development",
   "type": "module",
   "bin": {

package/claude/skills/product-planning.md

@@ -1,136 +0,0 @@
----
-name: product-planning
-description: Help with product planning, feature brainstorming, and backlog management using Linear.
-allowed-tools: Bash(linear:*), Bash(curl:*)
----
-
-# Product Planning Skill
-
-Help the developer think through product direction, brainstorm features, and manage their Linear backlog.
-
-## When to Use This Skill
-
-Use this skill when the developer wants to:
-- Brainstorm new features or improvements
-- Review and prioritize the backlog
-- Break down large ideas into actionable issues
-- Plan a new phase or milestone
-- Think through product strategy
-
-## Approach
-
-### 1. Understand Current State
-
-First, gather context:
-
-```bash
-# See all open issues (backlog + in progress, excludes completed)
-linear issues --open
-
-# See active projects/phases
-linear projects
-```
-
-### 2. Facilitate Discussion
-
-Ask good questions to help clarify thinking:
-
-- "What problem are we trying to solve?"
-- "Who benefits from this feature?"
-- "What's the simplest version that would be valuable?"
-- "What are the dependencies or blockers?"
-- "How does this fit with the current phase?"
-
-### 3. Break Down Ideas
-
-When a feature is identified, help break it into Linear issues:
-
-**For small features (S/M):**
-- Create a single issue with clear acceptance criteria
-- Assign appropriate estimate
-
-**For large features (L/XL):**
-- Create a parent issue describing the overall goal
-- Break into sub-issues, each S or M sized
-- Identify dependencies between sub-issues
-
-```bash
-# Create parent issue
-linear issue create --title "User authentication system" --estimate L --project "Phase 2"
-
-# Create sub-issues
-linear issue create --title "Design auth flow" --parent ISSUE-10 --estimate S
-linear issue create --title "Implement login endpoint" --parent ISSUE-10 --estimate M
-linear issue create --title "Add session management" --parent ISSUE-10 --estimate M --blocked-by ISSUE-12
-```
-
-### 4. Organize Into Phases
-
-If planning a new phase:
-
-```bash
-# Create the phase
-linear project create "Phase 3: User Dashboard" --description "Build the main user-facing dashboard with key metrics"
-
-# Add issues to it
-linear issue create --title "Dashboard layout" --project "Phase 3" --estimate M
-```
-
-## Brainstorming Prompts
-
-When the developer is stuck, try these prompts:
-
-**For new features:**
-- "What do users complain about most?"
-- "What manual process could we automate?"
-- "What would make you excited to use this product?"
-
-**For improvements:**
-- "Where do users get confused?"
-- "What takes too long?"
-- "What breaks most often?"
-
-**For prioritization:**
-- "What would have the biggest impact with the least effort?"
-- "What's blocking other work?"
-- "What do users ask for most?"
-
-## Output Format
-
-After a planning session, summarize:
-
-1. **New issues created** - List with IDs and estimates
-2. **Backlog changes** - Any reprioritization or updates
-3. **Next steps** - What to work on next
-4. **Open questions** - Things that need more thought
-
-## Example Session
-
-```
-Developer: "I want to add user notifications"
-
-Claude: Let me check the current state...
-[runs linear issues --all]
-
-Good context. A few questions:
-1. What triggers notifications? (events, mentions, etc.)
-2. Where do they appear? (in-app, email, push?)
-3. Is this blocking other work?
-
-Developer: "Just in-app for now, triggered by comments on their issues"
-
-That's a nicely scoped M-sized feature. Let me create it:
-[runs linear issue create --title "In-app notifications for issue comments" --estimate M --project "Phase 2"]
-
-Created ISSUE-15. Should I break this down further, or is it small enough to tackle as one unit?
-```
-
-## Integration with /next
-
-When invoked from the `/next` command (user chose "product planning"), start by asking:
-
-"What would you like to focus on today?"
-- Review and prioritize the backlog
-- Brainstorm new features
-- Plan the next phase
-- Something specific (let them describe)