prjct-cli 0.40.0 → 0.42.0

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## [0.42.0] - 2026-01-29
+
+### Feature: Linear SDK Integration with Per-Project Credentials
+
+Linear integration now uses the native `@linear/sdk` with per-project credential storage, enabling different projects to use different Linear workspaces.
+
+**New: Per-Project Credentials**
+- Credentials stored at `~/.prjct-cli/projects/{projectId}/config/credentials.json`
+- Fallback chain: project credentials → macOS keychain → environment variable
+- Each project can connect to a different Linear workspace
+
+**New: CLI Bridge (`core/cli/linear.ts`)**
+- Direct access to Linear SDK from templates
+- Commands: `setup`, `list`, `get`, `create`, `update`, `start`, `done`, `comment`, `teams`, `projects`, `status`
+- JSON output for easy parsing by Claude
+
+**New: `prjct linear <cmd>` Subcommand**
+- Direct CLI access: `prjct linear status`, `prjct linear list`, etc.
+- Auto-resolves project ID from current directory
+
+**Updated Templates**
+- `linear.md` — Natural language interpretation guide for Claude
+- `enrich.md` — Uses CLI instead of MCP for ticket enrichment
+
+**Breaking: Removed MCP-only Trackers**
+- Removed JIRA, GitHub Issues, Monday.com support (no native SDK)
+- Only Linear is supported (has native SDK)
+
+**New Files:**
+- `core/cli/linear.ts` — CLI bridge for Linear SDK
+- `core/utils/project-credentials.ts` — Per-project credential storage
+
+**Modified:**
+- `bin/prjct.ts` — Added `prjct linear` subcommand
+- `templates/commands/linear.md` — Updated with CLI execution pattern
+- `templates/commands/enrich.md` — Linear-only, uses CLI
+
 ## [0.40.0] - 2026-01-28
 
 ### Feature: Enhanced Skill System

package/bin/prjct.ts

@@ -85,6 +85,32 @@ if (args[0] === 'start' || args[0] === 'setup') {
     console.error('Server error:', (error as Error).message)
     process.exitCode = 1
   }
+} else if (args[0] === 'linear') {
+  // Linear CLI subcommand - direct access to Linear SDK
+  const { spawn } = await import('child_process')
+  const projectPath = process.cwd()
+  const projectId = await configManager.getProjectId(projectPath)
+
+  if (!projectId) {
+    console.error('No prjct project found. Run "prjct init" first.')
+    process.exitCode = 1
+  } else {
+    // Get the path to the linear CLI
+    const linearCliPath = path.join(__dirname, '..', 'core', 'cli', 'linear.ts')
+
+    // Forward args to linear CLI, adding --project flag
+    const linearArgs = ['--project', projectId, ...args.slice(1)]
+
+    // Use bun to run the CLI
+    const child = spawn('bun', [linearCliPath, ...linearArgs], {
+      stdio: 'inherit',
+      cwd: projectPath,
+    })
+
+    child.on('close', (code) => {
+      process.exitCode = code || 0
+    })
+  }
 } else if (args[0] === 'version' || args[0] === '-v' || args[0] === '--version') {
   // Show version with provider status
   const detection = detectAllProviders()

package/core/cli/linear.ts

@@ -0,0 +1,381 @@
+#!/usr/bin/env bun
+/**
+ * Linear CLI - Bridge between templates and SDK
+ *
+ * Usage: bun core/cli/linear.ts --project <projectId> <command> [args...]
+ *
+ * Commands:
+ *   setup <apiKey> [teamId]    - Store API key in project credentials
+ *   list                       - List my assigned issues
+ *   list-team <teamId>         - List issues from a team
+ *   get <id>                   - Get issue by ID or identifier (PRJ-123)
+ *   create <json>              - Create issue from JSON input
+ *   update <id> <json>         - Update issue
+ *   start <id>                 - Mark issue as in progress
+ *   done <id>                  - Mark issue as done
+ *   comment <id> <text>        - Add comment to issue
+ *   teams                      - List available teams
+ *   projects                   - List available projects
+ *   status                     - Check connection status
+ *
+ * All output is JSON for easy parsing by Claude.
+ */
+
+import { linearService } from '../integrations/linear'
+import {
+  getLinearApiKey,
+  setLinearCredentials,
+  getProjectCredentials,
+  getCredentialSource,
+} from '../utils/project-credentials'
+
+// Parse arguments
+const args = process.argv.slice(2)
+
+// Extract --project flag
+const projectIdx = args.indexOf('--project')
+let projectId: string | null = null
+if (projectIdx !== -1 && args[projectIdx + 1]) {
+  projectId = args[projectIdx + 1]
+  args.splice(projectIdx, 2)
+}
+
+const [command, ...commandArgs] = args
+
+/**
+ * Output result as JSON
+ */
+function output(data: unknown): void {
+  console.log(JSON.stringify(data, null, 2))
+}
+
+/**
+ * Output error as JSON and exit
+ */
+function error(message: string, code = 1): never {
+  console.error(JSON.stringify({ error: message }))
+  process.exit(code)
+}
+
+/**
+ * Initialize Linear service from project credentials
+ */
+async function initFromProject(): Promise<void> {
+  if (!projectId) {
+    error('No --project specified. Usage: linear.ts --project <projectId> <command>')
+  }
+
+  const apiKey = await getLinearApiKey(projectId)
+  if (!apiKey) {
+    error('Linear not configured. Run: p. linear setup')
+  }
+
+  const creds = await getProjectCredentials(projectId)
+  await linearService.initializeFromApiKey(apiKey, creds.linear?.teamId)
+}
+
+/**
+ * Main CLI handler
+ */
+async function main(): Promise<void> {
+  try {
+    switch (command) {
+      case 'setup': {
+        if (!projectId) {
+          error('--project required for setup')
+        }
+
+        const apiKey = commandArgs[0]
+        const teamId = commandArgs[1] // optional
+
+        if (!apiKey) {
+          error('API key required. Usage: setup <apiKey> [teamId]')
+        }
+
+        // Test connection first
+        await linearService.initializeFromApiKey(apiKey, teamId)
+        const teams = await linearService.getTeams()
+
+        if (teams.length === 0) {
+          error('No teams found. Check your API key permissions.')
+        }
+
+        // Determine default team
+        let selectedTeamId = teamId
+        let selectedTeamKey: string | undefined
+
+        if (!selectedTeamId && teams.length === 1) {
+          selectedTeamId = teams[0].id
+          selectedTeamKey = teams[0].key
+        } else if (selectedTeamId) {
+          const team = teams.find((t) => t.id === selectedTeamId || t.key === selectedTeamId)
+          if (team) {
+            selectedTeamId = team.id
+            selectedTeamKey = team.key
+          }
+        }
+
+        // Store in project credentials
+        await setLinearCredentials(projectId, {
+          apiKey,
+          teamId: selectedTeamId,
+          teamKey: selectedTeamKey,
+          setupAt: new Date().toISOString(),
+        })
+
+        output({
+          success: true,
+          teams,
+          defaultTeam: selectedTeamId
+            ? { id: selectedTeamId, key: selectedTeamKey }
+            : null,
+        })
+        break
+      }
+
+      case 'list': {
+        await initFromProject()
+        const limit = commandArgs[0] ? parseInt(commandArgs[0], 10) : 20
+        const issues = await linearService.fetchAssignedIssues({ limit })
+        output({
+          count: issues.length,
+          issues: issues.map((issue) => ({
+            id: issue.id,
+            identifier: issue.externalId,
+            title: issue.title,
+            status: issue.status,
+            priority: issue.priority,
+            url: issue.url,
+          })),
+        })
+        break
+      }
+
+      case 'list-team': {
+        await initFromProject()
+        const teamId = commandArgs[0]
+        const limit = commandArgs[1] ? parseInt(commandArgs[1], 10) : 20
+
+        if (!teamId) {
+          error('Team ID required. Usage: list-team <teamId> [limit]')
+        }
+
+        const issues = await linearService.fetchTeamIssues(teamId, { limit })
+        output({
+          count: issues.length,
+          issues: issues.map((issue) => ({
+            id: issue.id,
+            identifier: issue.externalId,
+            title: issue.title,
+            status: issue.status,
+            priority: issue.priority,
+            url: issue.url,
+          })),
+        })
+        break
+      }
+
+      case 'get': {
+        await initFromProject()
+        const id = commandArgs[0]
+
+        if (!id) {
+          error('Issue ID required. Usage: get <id>')
+        }
+
+        const issue = await linearService.fetchIssue(id)
+        if (!issue) {
+          error(`Issue not found: ${id}`)
+        }
+
+        output(issue)
+        break
+      }
+
+      case 'create': {
+        await initFromProject()
+        const inputJson = commandArgs[0]
+
+        if (!inputJson) {
+          error('JSON input required. Usage: create \'{"title":"...", "teamId":"..."}\'')
+        }
+
+        let input
+        try {
+          input = JSON.parse(inputJson)
+        } catch {
+          error(`Invalid JSON: ${inputJson}`)
+        }
+
+        if (!input.title) {
+          error('title is required')
+        }
+        if (!input.teamId) {
+          // Try to use default team from credentials
+          const creds = await getProjectCredentials(projectId!)
+          if (creds.linear?.teamId) {
+            input.teamId = creds.linear.teamId
+          } else {
+            error('teamId is required (no default team configured)')
+          }
+        }
+
+        const issue = await linearService.createIssue(input)
+        output(issue)
+        break
+      }
+
+      case 'update': {
+        await initFromProject()
+        const id = commandArgs[0]
+        const inputJson = commandArgs[1]
+
+        if (!id) {
+          error('Issue ID required. Usage: update <id> \'{"description":"..."}\'')
+        }
+        if (!inputJson) {
+          error('JSON input required. Usage: update <id> \'{"description":"..."}\'')
+        }
+
+        let input
+        try {
+          input = JSON.parse(inputJson)
+        } catch {
+          error(`Invalid JSON: ${inputJson}`)
+        }
+
+        const issue = await linearService.updateIssue(id, input)
+        output(issue)
+        break
+      }
+
+      case 'start': {
+        await initFromProject()
+        const id = commandArgs[0]
+
+        if (!id) {
+          error('Issue ID required. Usage: start <id>')
+        }
+
+        await linearService.markInProgress(id)
+        output({ success: true, id, status: 'in_progress' })
+        break
+      }
+
+      case 'done': {
+        await initFromProject()
+        const id = commandArgs[0]
+
+        if (!id) {
+          error('Issue ID required. Usage: done <id>')
+        }
+
+        await linearService.markDone(id)
+        output({ success: true, id, status: 'done' })
+        break
+      }
+
+      case 'comment': {
+        await initFromProject()
+        const id = commandArgs[0]
+        const body = commandArgs.slice(1).join(' ')
+
+        if (!id) {
+          error('Issue ID required. Usage: comment <id> <text>')
+        }
+        if (!body) {
+          error('Comment text required. Usage: comment <id> <text>')
+        }
+
+        await linearService.addComment(id, body)
+        output({ success: true, id })
+        break
+      }
+
+      case 'teams': {
+        await initFromProject()
+        const teams = await linearService.getTeams()
+        output({ count: teams.length, teams })
+        break
+      }
+
+      case 'projects': {
+        await initFromProject()
+        const projects = await linearService.getProjects()
+        output({ count: projects.length, projects })
+        break
+      }
+
+      case 'status': {
+        if (!projectId) {
+          error('--project required for status')
+        }
+
+        const source = await getCredentialSource(projectId)
+        const apiKey = await getLinearApiKey(projectId)
+        const creds = await getProjectCredentials(projectId)
+
+        if (!apiKey) {
+          output({
+            configured: false,
+            source: 'none',
+            message: 'Linear not configured. Run: p. linear setup',
+          })
+          break
+        }
+
+        // Test connection
+        try {
+          await linearService.initializeFromApiKey(apiKey, creds.linear?.teamId)
+          const teams = await linearService.getTeams()
+
+          output({
+            configured: true,
+            source,
+            teamId: creds.linear?.teamId,
+            teamKey: creds.linear?.teamKey,
+            teamsAvailable: teams.length,
+          })
+        } catch (err) {
+          output({
+            configured: true,
+            source,
+            connectionError: (err as Error).message,
+          })
+        }
+        break
+      }
+
+      case 'help':
+      case '--help':
+      case '-h':
+      case undefined: {
+        output({
+          usage: 'linear.ts --project <projectId> <command> [args...]',
+          commands: {
+            setup: 'setup <apiKey> [teamId] - Store API key',
+            list: 'list [limit] - List my assigned issues',
+            'list-team': 'list-team <teamId> [limit] - List team issues',
+            get: 'get <id> - Get issue by ID or identifier',
+            create: 'create <json> - Create issue',
+            update: 'update <id> <json> - Update issue',
+            start: 'start <id> - Mark as in progress',
+            done: 'done <id> - Mark as done',
+            comment: 'comment <id> <text> - Add comment',
+            teams: 'teams - List available teams',
+            projects: 'projects - List available projects',
+            status: 'status - Check connection',
+          },
+        })
+        break
+      }
+
+      default:
+        error(`Unknown command: ${command}. Use --help to see available commands.`)
+    }
+  } catch (err) {
+    error((err as Error).message)
+  }
+}
+
+main()

package/core/integrations/jira/cache.ts

@@ -0,0 +1,57 @@
+/**
+ * JIRA Cache Module
+ * 5-minute TTL cache for JIRA API responses to reduce API calls
+ */
+
+import { TTLCache } from '../../utils/cache'
+import type { Issue } from '../issue-tracker/types'
+
+// 5-minute TTL for JIRA API responses
+const JIRA_CACHE_TTL = 5 * 60 * 1000 // 300000ms
+
+/**
+ * Cache for individual issues (by key like "ENG-123" or ID)
+ * Key format: "issue:{key}" or "issue:{id}"
+ */
+export const issueCache = new TTLCache<Issue>({
+  ttl: JIRA_CACHE_TTL,
+  maxSize: 100,
+})
+
+/**
+ * Cache for assigned issues list
+ * Key format: "assigned:{userId}" or "assigned:me"
+ */
+export const assignedIssuesCache = new TTLCache<Issue[]>({
+  ttl: JIRA_CACHE_TTL,
+  maxSize: 10,
+})
+
+/**
+ * Cache for projects list
+ * Key format: "projects"
+ */
+export const projectsCache = new TTLCache<Array<{ id: string; name: string; key?: string }>>({
+  ttl: JIRA_CACHE_TTL,
+  maxSize: 5,
+})
+
+/**
+ * Clear all JIRA caches
+ */
+export function clearJiraCache(): void {
+  issueCache.clear()
+  assignedIssuesCache.clear()
+  projectsCache.clear()
+}
+
+/**
+ * Get cache statistics for debugging
+ */
+export function getJiraCacheStats() {
+  return {
+    issues: issueCache.stats(),
+    assignedIssues: assignedIssuesCache.stats(),
+    projects: projectsCache.stats(),
+  }
+}

package/core/integrations/jira/index.ts

@@ -1,25 +1,30 @@
 /**
  * JIRA Integration
  *
- * Provides JIRA issue tracking integration for prjct-cli.
+ * Provides JIRA issue tracking integration for prjct-cli using REST API.
  *
- * Two authentication modes:
- *
- * 1. API Token Mode (direct REST API):
+ * Authentication (API Token Mode):
  *    - JIRA_BASE_URL: Your JIRA instance URL (e.g., https://company.atlassian.net)
  *    - JIRA_EMAIL: Your Atlassian account email
  *    - JIRA_API_TOKEN: API token from https://id.atlassian.com/manage-profile/security/api-tokens
- *
- * 2. MCP Mode (for corporate SSO):
- *    - No environment variables needed
- *    - Requires Atlassian MCP server configured in ~/.claude/mcp.json
- *    - Authenticates via browser (OAuth 2.1, SSO compatible)
  */
 
-// REST API client (supports both API token and MCP modes)
+// REST API client
 export { JiraProvider, jiraProvider, type JiraAuthMode } from './client'
 
-// MCP adapter for generating Claude instructions
+// Service layer with caching (preferred API)
+export { JiraService, jiraService } from './service'
+
+// Cache utilities
+export {
+  issueCache,
+  assignedIssuesCache,
+  projectsCache,
+  clearJiraCache,
+  getJiraCacheStats,
+} from './cache'
+
+// MCP adapter (deprecated - will be removed)
 export {
   JiraMCPAdapter,
   jiraMCPAdapter,