prjct-cli 0.41.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/utils/project-credentials.ts

@@ -0,0 +1,148 @@
+/**
+ * Per-project credential storage
+ *
+ * Stores credentials in: ~/.prjct-cli/projects/{projectId}/config/credentials.json
+ *
+ * Fallback chain for Linear API key:
+ * 1. Project credentials (per-project)
+ * 2. Global keychain (macOS)
+ * 3. Environment variables
+ *
+ * This allows different projects to use different Linear workspaces.
+ */
+
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+import { getCredential, type CredentialKey } from './keychain'
+
+interface LinearCredentials {
+  apiKey: string
+  teamId?: string
+  teamKey?: string
+  setupAt: string
+}
+
+export interface ProjectCredentials {
+  linear?: LinearCredentials
+}
+
+/**
+ * Get path to project credentials file
+ */
+function getCredentialsPath(projectId: string): string {
+  return path.join(
+    os.homedir(),
+    '.prjct-cli',
+    'projects',
+    projectId,
+    'config',
+    'credentials.json'
+  )
+}
+
+/**
+ * Get all credentials for a project
+ */
+export async function getProjectCredentials(projectId: string): Promise<ProjectCredentials> {
+  const credPath = getCredentialsPath(projectId)
+  if (!fs.existsSync(credPath)) {
+    return {}
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(credPath, 'utf-8'))
+  } catch (error) {
+    console.error('[project-credentials] Failed to read credentials:', (error as Error).message)
+    return {}
+  }
+}
+
+/**
+ * Set Linear credentials for a project
+ */
+export async function setLinearCredentials(
+  projectId: string,
+  credentials: LinearCredentials
+): Promise<void> {
+  const credPath = getCredentialsPath(projectId)
+  const dir = path.dirname(credPath)
+
+  // Ensure directory exists
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true })
+  }
+
+  // Read existing, merge, write
+  const current = await getProjectCredentials(projectId)
+  current.linear = credentials
+  fs.writeFileSync(credPath, JSON.stringify(current, null, 2))
+}
+
+/**
+ * Delete Linear credentials for a project
+ */
+export async function deleteLinearCredentials(projectId: string): Promise<void> {
+  const current = await getProjectCredentials(projectId)
+
+  if (current.linear) {
+    delete current.linear
+    const credPath = getCredentialsPath(projectId)
+    fs.writeFileSync(credPath, JSON.stringify(current, null, 2))
+  }
+}
+
+/**
+ * Get Linear API key with fallback chain:
+ * 1. Project credentials
+ * 2. Global keychain
+ * 3. Environment variable
+ */
+export async function getLinearApiKey(projectId: string): Promise<string | null> {
+  // 1. Project credentials
+  const projectCreds = await getProjectCredentials(projectId)
+  if (projectCreds.linear?.apiKey) {
+    return projectCreds.linear.apiKey
+  }
+
+  // 2. Global keychain (falls back to env var internally)
+  return getCredential('linear-api-key' as CredentialKey)
+}
+
+/**
+ * Get Linear team ID from project credentials
+ */
+export async function getLinearTeamId(projectId: string): Promise<string | undefined> {
+  const projectCreds = await getProjectCredentials(projectId)
+  return projectCreds.linear?.teamId
+}
+
+/**
+ * Check if Linear is configured for a project
+ */
+export async function isLinearConfigured(projectId: string): Promise<boolean> {
+  const apiKey = await getLinearApiKey(projectId)
+  return apiKey !== null && apiKey.length > 0
+}
+
+/**
+ * Get credential source for debugging
+ */
+export async function getCredentialSource(
+  projectId: string
+): Promise<'project' | 'keychain' | 'env' | 'none'> {
+  // Check project credentials
+  const projectCreds = await getProjectCredentials(projectId)
+  if (projectCreds.linear?.apiKey) {
+    return 'project'
+  }
+
+  // Check keychain/env
+  const { getCredentialWithSource } = await import('./keychain')
+  const result = await getCredentialWithSource('linear-api-key' as CredentialKey)
+  if (result.value) {
+    return result.source === 'keychain' ? 'keychain' : 'env'
+  }
+
+  return 'none'
+}

package/dist/bin/prjct.mjs

@@ -15888,7 +15888,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "0.40.0",
+      version: "0.41.0",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {
@@ -17033,6 +17033,24 @@ if (args[0] === "start" || args[0] === "setup") {
     console.error("Server error:", error.message);
     process.exitCode = 1;
   }
+} else if (args[0] === "linear") {
+  const { spawn } = await import("child_process");
+  const projectPath = process.cwd();
+  const projectId = await config_manager_default.getProjectId(projectPath);
+  if (!projectId) {
+    console.error('No prjct project found. Run "prjct init" first.');
+    process.exitCode = 1;
+  } else {
+    const linearCliPath = path40.join(__dirname, "..", "core", "cli", "linear.ts");
+    const linearArgs = ["--project", projectId, ...args.slice(1)];
+    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") {
   const detection = detectAllProviders();
   const home = os13.homedir();