prjct-cli 0.35.2 → 0.35.4

package/package.json

@@ -1,21 +1,17 @@
 {
   "name": "prjct-cli",
-  "version": "0.35.2",
+  "version": "0.35.4",
   "description": "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
   "main": "core/index.ts",
   "bin": {
     "prjct": "bin/prjct"
   },
-  "workspaces": [
-    "packages/*"
-  ],
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
   "scripts": {
     "build": "node scripts/build.js",
-    "build:shared": "bun run --filter '@prjct/shared' build",
     "build:node": "node scripts/build.js",
     "release": "node scripts/release.js",
     "release:patch": "node scripts/release.js patch",
@@ -91,15 +87,13 @@
     "bin/",
     "core/",
     "dist/",
-    "packages/shared/",
     "templates/",
     "scripts/postinstall.js",
     "scripts/build.js",
     "scripts/install.sh",
     "LICENSE",
     "README.md",
-    "CHANGELOG.md",
-    "CLAUDE.md"
+    "CHANGELOG.md"
   ],
   "trustedDependencies": [
     "chalk",

package/templates/_bases/tracker-base.md

@@ -0,0 +1,309 @@
+---
+allowed-tools: [Read, Write, Bash, AskUserQuestion]
+description: 'Base template for issue tracker integrations'
+---
+
+# Issue Tracker Base Template
+
+**This is a BASE TEMPLATE. Do not execute directly.**
+
+All issue tracker integrations (Linear, JIRA, GitHub Issues, Monday.com) inherit from this base.
+
+---
+
+## Common Context Variables
+
+- `{projectId}`: From `.prjct/prjct.config.json`
+- `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
+- `{args}`: User-provided arguments (subcommand)
+- `{tracker}`: The tracker name (linear, jira, github, monday)
+- `{mcpPrefix}`: MCP tool prefix (e.g., `mcp__linear__`, `mcp__atlassian__jira_`)
+
+---
+
+## Standard Subcommands
+
+All trackers MUST support these subcommands:
+
+| Command | Description |
+|---------|-------------|
+| `p. {tracker}` | Show status + your assigned issues |
+| `p. {tracker} setup` | Configure integration (REQUIRED FIRST) |
+| `p. {tracker} start <ID>` | Start working on issue |
+| `p. {tracker} comment <ID> <text>` | Add comment to issue |
+
+---
+
+## Step 1: Validate Project (COMMON)
+
+```
+READ: .prjct/prjct.config.json
+EXTRACT: projectId
+SET: globalPath = ~/.prjct-cli/projects/{projectId}
+
+IF file not found:
+  OUTPUT: "No prjct project. Run `p. init` first."
+  STOP
+```
+
+---
+
+## Step 2: Check Authentication (TRACKER-SPECIFIC)
+
+**Override this section per tracker.**
+
+Common patterns:
+- **MCP OAuth** (Linear, JIRA): First use opens browser
+- **API Token** (GitHub): Requires env var
+- **Both supported** (JIRA): OAuth preferred, token fallback
+
+```
+# Check for existing config
+READ: {globalPath}/project.json → integrations.{tracker}
+
+IF config exists AND config.enabled:
+  # Use existing credentials
+  SET: authMode = config.authMode
+ELSE:
+  # Need setup
+  OUTPUT: "{TRACKER} not configured. Run `p. {tracker} setup` first."
+  STOP
+```
+
+---
+
+## Step 3: Install MCP Server (COMMON)
+
+```
+READ: ~/.claude/settings.json (create {} if not exists)
+CHECK: Does mcpServers.{mcpServerName} exist?
+
+IF not exists:
+  MERGE MCP config:
+  {
+    "mcpServers": {
+      "{mcpServerName}": {mcpConfig}
+    }
+  }
+
+  WRITE: ~/.claude/settings.json
+
+  OUTPUT: "✅ Installed {TRACKER} MCP server"
+  OUTPUT: ""
+  OUTPUT: "⚠️ Restart Claude Code to activate the MCP server."
+  OUTPUT: "Then run `p. {tracker} setup` again to complete configuration."
+  STOP
+```
+
+---
+
+## Step 4: Check MCP Tools Available (COMMON)
+
+```
+CHECK: Are {mcpPrefix}* tools available?
+
+IF not available:
+  OUTPUT: "{TRACKER} MCP is installed but not yet active."
+  OUTPUT: "Restart Claude Code, then run `p. {tracker} setup` again."
+  STOP
+```
+
+---
+
+## Subcommand: setup (COMMON FLOW)
+
+### Flow
+
+1. **Install MCP + Verify tools available**
+   - Execute Step 3 (auto-install if needed)
+   - Execute Step 4 (verify tools active)
+   - IF not available: Prompt restart and STOP
+
+2. **Test connection (TRACKER-SPECIFIC)**
+   - Call list/get endpoint to verify auth
+   - MCP OAuth may open browser on first call
+
+3. **Get user info (TRACKER-SPECIFIC)**
+   - Get current user
+   - List available projects/teams
+
+4. **Ask user to select project/team**
+   ```
+   ASK: "Select your default {project|team|board}"
+   OPTIONS: List from step 3
+   ```
+
+5. **Save config to project.json**
+   ```json
+   {
+     "integrations": {
+       "{tracker}": {
+         "enabled": true,
+         "authMode": "{mcp|token}",
+         "{projectKey}": "{selected}",
+         "setupAt": "{timestamp}"
+       }
+     }
+   }
+   ```
+
+### Output
+
+```
+✅ {TRACKER} configured
+
+{Connected as: {user} (if available)}
+{Project|Team}: {name}
+Auth: {authMode}
+
+Next: `p. {tracker}` to see your issues
+```
+
+---
+
+## Subcommand: status (default, no args) - COMMON FLOW
+
+```
+1. Validate auth (Step 2)
+2. Call list issues API with assignee filter
+3. Format and display
+
+OUTPUT:
+{TRACKER}: Connected ✓
+{Project|Team}: {name}
+
+Your issues ({count}):
+• {ID-1} {title} ({status})
+• {ID-2} {title} ({status})
+...
+
+Next: `p. {tracker} start {ID}` to begin work
+```
+
+---
+
+## Subcommand: start <ID> - COMMON FLOW
+
+```
+1. Get issue by ID
+   USE: {mcpPrefix}get_issue or equivalent
+
+2. Update status to "In Progress"
+   USE: {mcpPrefix}update_issue or transition
+
+3. Create prjct task from issue
+   - Extract title, description
+   - Create task with linked issueId
+
+4. Create git branch
+   SET: branchName = {type}/{ID}-{slug}
+   BASH: git checkout -b {branchName}
+
+OUTPUT:
+Started: {ID} - {title}
+
+Branch: {branchName}
+{TRACKER}: In Progress ✓
+
+Next: Work on the task, then `p. done`
+```
+
+---
+
+## Subcommand: comment <ID> <text> - COMMON FLOW
+
+```
+1. Get issue ID (may need to lookup)
+2. Add comment via MCP
+
+OUTPUT:
+Comment added to {ID}
+```
+
+---
+
+## Config Storage (COMMON)
+
+| What | Where |
+|------|-------|
+| Auth | Varies: Env var, MCP OAuth, or keychain |
+| Config | `{globalPath}/project.json` → `integrations.{tracker}` |
+| Issue cache | `{globalPath}/storage/issues.json` (optional) |
+
+---
+
+## Error Handling (COMMON)
+
+| Error | Action |
+|-------|--------|
+| No project | "Run `p. init` first" |
+| Auth not configured | "Run `p. {tracker} setup` first" |
+| MCP tools not found | "Restart Claude Code after setup" |
+| Auth failed | Re-authenticate message |
+| Issue not found | "Issue {ID} not found in {TRACKER}" |
+| Rate limited | "Rate limited. Try again later" |
+
+---
+
+## Output Format (COMMON)
+
+```
+{action}: {result}
+
+{details}
+
+Next: {suggested action}
+```
+
+---
+
+## MCP Tool Mapping
+
+| Operation | Pattern |
+|-----------|---------|
+| List issues | `{mcpPrefix}list_issues` |
+| Get issue | `{mcpPrefix}get_issue` |
+| Update issue | `{mcpPrefix}update_issue` |
+| Create issue | `{mcpPrefix}create_issue` |
+| Add comment | `{mcpPrefix}create_comment` |
+
+---
+
+## Tracker-Specific Overrides
+
+When implementing a tracker:
+
+1. **INHERIT** all common flows from this base
+2. **OVERRIDE** authentication check with tracker-specific logic
+3. **IMPLEMENT** MCP tool calls with correct tool names
+4. **ADD** tracker-specific subcommands if needed
+
+---
+
+## Example Implementation Pattern
+
+```markdown
+# p. {tracker} - {Tracker Name} Integration
+
+**EXTENDS**: `_bases/tracker-base.md`
+
+## Tracker-Specific Config
+
+- `{mcpServerName}`: "{mcp server identifier}"
+- `{mcpPrefix}`: "{tool prefix}"
+- `{projectKey}`: "{what they call it - team, project, repo}"
+
+## Authentication Override
+
+{Tracker-specific auth flow}
+
+## MCP Tool Reference
+
+| Operation | MCP Tool |
+|-----------|----------|
+{Tracker-specific tool mappings}
+
+## Additional Subcommands (if any)
+
+{Tracker-specific commands}
+```

package/templates/agentic/agent-routing.md

@@ -1,111 +1,45 @@
 ---
 allowed-tools: [Read]
-description: 'Determine which agent should handle a task - Claude decides'
 ---
 
-# Agent Routing Instructions
+# Agent Routing
 
-## Objective
+Determine best agent for a task.
 
-Determine the best agent for a task by analyzing the ACTUAL task and project context.
+## Process
 
-## Step 1: Understand the Task
+1. **Understand task**: What files? What work? What knowledge?
+2. **Read project context**: Technologies, structure, patterns
+3. **Match to agent**: Based on analysis, not assumptions
 
-Read the task description and identify:
+## Agent Types
 
-- What files will be modified?
-- What type of work is involved?
-- What knowledge is required?
+| Type | Domain |
+|------|--------|
+| Frontend/UX | UI components, styling |
+| Backend | API, server logic |
+| Database | Schema, queries, migrations |
+| DevOps/QA | Testing, CI/CD |
+| Full-stack | Cross-cutting concerns |
 
-## Step 2: Read Project Context
-
-If project analysis exists, read it to understand:
-
-- What technologies are actually used
-- How the project is structured
-- What patterns are established
-
-## Step 3: Match Task to Agent
-
-Based on your analysis, determine which agent is best suited:
-
-**DO NOT assume:**
-- "React" = frontend agent
-- "Express" = backend agent
-- "Database" = database agent
-
-**DO analyze:**
-- What the task actually requires
-- What files will be touched
-- What expertise is needed
-
-## Available Agent Types
-
-Consider these agent specializations:
-
-- **Coordinator**: High-level planning, task breakdown
-- **Frontend/UX**: UI components, user experience, styling
-- **Backend**: API endpoints, server logic, business rules
-- **Database**: Schema design, queries, migrations
-- **DevOps/QA**: Testing, CI/CD, deployment, infrastructure
-- **Full-stack**: Cross-cutting concerns, multiple layers
-
-## Decision Process
-
-1. Read task description
-2. Identify primary area of work
-3. Consider secondary areas
-4. Choose agent with best expertise match
-
-## How to Invoke (EFFICIENT)
-
-After deciding the best agent, **delegate via Task tool with REFERENCE, not content**:
+## Delegation
 
 ```
 Task(
   subagent_type: 'general-purpose',
   prompt: '
-    ## Agent Assignment
-    Read and apply: ~/.prjct-cli/projects/{projectId}/agents/{agent-name}.md
-
-    ## Task
-    {task description}
-
-    ## Context
-    - Project: {projectPath}
-    - Files affected: {file list if known}
-
-    ## Flow
-    1. Read agent file FIRST
-    2. Apply agent expertise and patterns
-    3. Execute task following agent guidelines
-    4. Return results
+    Read: ~/.prjct-cli/projects/{projectId}/agents/{agent}.md
+    Task: {description}
+    Execute using agent patterns.
   '
 )
 ```
 
-### Why References, Not Content
+**Pass PATH, not CONTENT** - subagent reads what it needs.
 
-| Approach | Prompt Size | Issue |
-|----------|-------------|-------|
-| ❌ Inject content | 3-5KB | Bloats context, increases hallucinations |
-| ✅ Pass reference | ~200 bytes | Subagent reads what it needs |
-
-**CRITICAL:** The subagent reads the agent file itself. You do NOT need to read and inject the content.
-
-## Output (After Delegation)
-
-After Task tool returns, summarize:
+## Output
 
 ```
-✅ Delegated to: {agent-name}
-Result: {brief summary from subagent}
+✅ Delegated to: {agent}
+Result: {summary}
 ```
-
-## Rules
-
-- **Task-driven, not tech-driven** - Focus on what needs to be done
-- **Context matters** - Same tech can mean different things in different projects
-- **Be flexible** - One project's "backend" might be another's "full-stack"
-- **Pass PATH, not CONTENT** - Let subagent read the agent file
-- **Explain your reasoning** - Don't just pick, justify