@dabble/linear-cli 1.0.1 → 1.0.2

package/claude/skills/linear-cli.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.md

@@ -1,136 +1,105 @@
 ---
 name: product-planning
-description: Help with product planning, feature brainstorming, and backlog management using Linear.
-allowed-tools: Bash(linear:*), Bash(curl:*)
+description: Facilitate product thinking and structure work in Linear.
+allowed-tools: Bash(linear:*), Bash(curl:*), "WebFetch(domain:*)", "WebSearch"
 ---
 
-# Product Planning Skill
+# Product Planning
 
-Help the developer think through product direction, brainstorm features, and manage their Linear backlog.
+Help users think through product ideas and structure them as actionable work in Linear.
 
-## When to Use This Skill
+## Mindset
 
-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
+- **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
 
-## Approach
+## Style
 
-### 1. Understand Current State
+Like Jason Fried without swearing. Concise, simple wording. Short back-and-forth dialog over long answers. Casual.
 
-First, gather context:
+## Start: Gather Context
 
 ```bash
-# See all open issues (backlog + in progress, excludes completed)
-linear issues --open
-
-# See active projects/phases
-linear projects
+linear roadmap        # Projects, milestones, progress
+linear issues --open  # Active work
 ```
 
-### 2. Facilitate Discussion
-
-Ask good questions to help clarify thinking:
+Read `product.md` if it exists—contains product vision, brand, tech decisions, prior planning context.
 
-- "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?"
+Offer web research when exploring new territory (market landscape, competitors, technical feasibility).
 
-### 3. Break Down Ideas
+## Process
 
-When a feature is identified, help break it into Linear issues:
+### 1. Explore the Problem
 
-**For small features (S/M):**
-- Create a single issue with clear acceptance criteria
-- Assign appropriate estimate
+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?
 
-**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
+### 2. Design the Solution
 
-```bash
-# Create parent issue
-linear issue create --title "User authentication system" --estimate L --project "Phase 2"
+- 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?
 
-# 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
-```
+Cut scope aggressively—except for core/differentiating features where polish and detail set you apart.
 
-### 4. Organize Into Phases
+### 3. Structure the Work
 
-If planning a new phase:
+**Sizing:** XS/S/M = single issue, < 1 day. L/XL = needs breakdown.
 
 ```bash
-# Create the phase
-linear project create "Phase 3: User Dashboard" --description "Build the main user-facing dashboard with key metrics"
+# Parent issue (the goal)
+linear issue create --title "User auth system" --estimate L --project "Phase 2"
 
-# Add issues to it
-linear issue create --title "Dashboard layout" --project "Phase 3" --estimate M
+# 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
 ```
 
-## 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
+### 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
 ```
-Developer: "I want to add user notifications"
 
-Claude: Let me check the current state...
-[runs linear issues --all]
+**Dependencies** make `--unblocked` useful:
+```bash
+linear issue create --title "Need API credentials" --blocks ISSUE-5
+```
 
-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?
+### 5. Prioritize
 
-Developer: "Just in-app for now, triggered by comments on their issues"
+```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
+```
 
-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"]
+## Update product.md
 
-Created ISSUE-15. Should I break this down further, or is it small enough to tackle as one unit?
-```
+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
 
-## Integration with /next
+Create the file if it doesn't exist. Keep it concise.
 
-When invoked from the `/next` command (user chose "product planning"), start by asking:
+## Session Summary
 
-"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)
+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.2",
   "description": "Linear CLI with unblocked issue filtering, built for AI-assisted development",
   "type": "module",
   "bin": {