prjct-cli 0.18.1 → 0.19.0

package/packages/web/lib/project-colors.ts

@@ -1,58 +0,0 @@
-/**
- * Project Colors - Consistent color generation based on projectId
- *
- * Uses a hash of the projectId to generate a consistent color
- * that matches between UI elements and browser tab titles.
- */
-
-// Color palette - visually distinct colors that work well in both
-// Tailwind classes and as emojis
-export const PROJECT_COLORS = [
-  { name: 'red', emoji: '🔴', bg: 'bg-red-500', text: 'text-red-500' },
-  { name: 'orange', emoji: '🟠', bg: 'bg-orange-500', text: 'text-orange-500' },
-  { name: 'yellow', emoji: '🟡', bg: 'bg-yellow-500', text: 'text-yellow-500' },
-  { name: 'green', emoji: '🟢', bg: 'bg-green-500', text: 'text-green-500' },
-  { name: 'blue', emoji: '🔵', bg: 'bg-blue-500', text: 'text-blue-500' },
-  { name: 'purple', emoji: '🟣', bg: 'bg-purple-500', text: 'text-purple-500' },
-  { name: 'brown', emoji: '🟤', bg: 'bg-amber-700', text: 'text-amber-700' },
-] as const
-
-export type ProjectColor = typeof PROJECT_COLORS[number]
-
-/**
- * Simple hash function for strings
- */
-function hashString(str: string): number {
-  let hash = 0
-  for (let i = 0; i < str.length; i++) {
-    const char = str.charCodeAt(i)
-    hash = ((hash << 5) - hash) + char
-    hash = hash & hash // Convert to 32bit integer
-  }
-  return Math.abs(hash)
-}
-
-/**
- * Get a consistent color for a project based on its ID
- */
-export function getProjectColor(projectId: string): ProjectColor {
-  const hash = hashString(projectId)
-  const index = hash % PROJECT_COLORS.length
-  return PROJECT_COLORS[index]
-}
-
-/**
- * Get just the emoji for a project (for use in titles)
- * Returns a neutral symbol instead of colored circles
- */
-export function getProjectEmoji(projectId: string): string {
-  return '▸'
-}
-
-/**
- * Get the Tailwind background class for a project
- * Returns neutral color - projects no longer have color-coded backgrounds
- */
-export function getProjectBgClass(projectId: string): string {
-  return 'bg-muted'
-}

package/packages/web/lib/projects.ts

@@ -1,506 +0,0 @@
-/**
- * Project utilities for prjct
- */
-
-import { promises as fs } from 'fs'
-import { join, dirname } from 'path'
-import { homedir } from 'os'
-import { exec } from 'child_process'
-import { promisify } from 'util'
-import { listSessions } from './pty'
-
-const execAsync = promisify(exec)
-
-export const GLOBAL_STORAGE = join(homedir(), '.prjct-cli', 'projects')
-export const TRASH_PATH = join(homedir(), '.prjct-cli', '.trash')
-
-// Cache for project paths (projectId -> real path)
-const projectPathCache = new Map<string, string>()
-
-/**
- * Scan common directories for .prjct/prjct.config.json files
- */
-export async function scanForProjects(): Promise<Map<string, string>> {
-  const searchPaths = [
-    join(homedir(), 'Apps'),
-    join(homedir(), 'Projects'),
-    join(homedir(), 'Documents'),
-    join(homedir(), 'Development'),
-    join(homedir(), 'Code'),
-    join(homedir(), 'dev'),
-  ]
-
-  for (const searchPath of searchPaths) {
-    try {
-      const { stdout } = await execAsync(
-        `find "${searchPath}" -maxdepth 4 -type f -name "prjct.config.json" -path "*/.prjct/*" 2>/dev/null`,
-        { timeout: 5000 }
-      )
-
-      const configFiles = stdout.trim().split('\n').filter(Boolean)
-
-      for (const configFile of configFiles) {
-        try {
-          const content = await fs.readFile(configFile, 'utf-8')
-          const config = JSON.parse(content)
-          if (config.projectId) {
-            const projectPath = dirname(dirname(configFile))
-            projectPathCache.set(config.projectId, projectPath)
-          }
-        } catch {
-          // Skip invalid config files
-        }
-      }
-    } catch {
-      // Skip directories that don't exist or are not accessible
-    }
-  }
-
-  return projectPathCache
-}
-
-/**
- * Extract project path from CLAUDE.md
- */
-export function extractProjectPath(claudeMd: string): string | null {
-  const pathMatch = claudeMd.match(/(?:Path|Location|Directory):\s*`?([^\n`]+)`?/i)
-  if (pathMatch) return pathMatch[1].trim()
-
-  const infoMatch = claudeMd.match(/\*\*Path\*\*:\s*`?([^\n`]+)`?/i)
-  if (infoMatch) return infoMatch[1].trim()
-
-  return null
-}
-
-/**
- * Get all projects with rich metadata
- */
-export async function getProjects() {
-  if (projectPathCache.size === 0) {
-    await scanForProjects()
-  }
-
-  const projects = []
-
-  try {
-    const dirs = await fs.readdir(GLOBAL_STORAGE)
-
-    for (const projectId of dirs) {
-      // Skip hidden directories like .trash
-      if (projectId.startsWith('.')) continue
-
-      const storagePath = join(GLOBAL_STORAGE, projectId)
-
-      // Try project.json first (source of truth)
-      let name: string = projectId
-      let repoPath: string | null = null
-      let techStack: string[] = []
-
-      try {
-        const projectJsonPath = join(storagePath, 'project.json')
-        const projectJson = JSON.parse(await fs.readFile(projectJsonPath, 'utf-8'))
-        name = projectJson.name || projectId
-        repoPath = projectJson.repoPath || null
-        techStack = projectJson.techStack || []
-      } catch {
-        // Fallback to CLAUDE.md for name/repoPath only
-        // techStack comes from project.json (populated by /p:sync)
-        try {
-          const claudeMd = await fs.readFile(join(storagePath, 'CLAUDE.md'), 'utf-8')
-          const nameMatch = claudeMd.match(/# (.+) - Project Context/)
-          if (nameMatch) name = nameMatch[1]
-
-          const cachedPath = projectPathCache.get(projectId)
-          repoPath = cachedPath || extractProjectPath(claudeMd)
-        } catch {
-          // Skip projects without valid config
-          continue
-        }
-      }
-
-      // Get current task
-      let currentTask: string | null = null
-      try {
-        const nowContent = await fs.readFile(join(storagePath, 'core', 'now.md'), 'utf-8')
-        // Skip headers like "# NOW", "# Current Task" and find the actual task content
-        // Look for **bold text** (task description) or first non-header, non-metadata line
-        const boldMatch = nowContent.match(/\*\*([^*]+)\*\*/)
-        if (boldMatch && boldMatch[1].trim() && !boldMatch[1].includes(':')) {
-          currentTask = boldMatch[1].trim()
-        } else {
-          // Find first content line that's not a header, metadata, or empty
-          const lines = nowContent.split('\n')
-          for (const line of lines) {
-            const trimmed = line.trim()
-            // Skip headers, empty lines, metadata lines (key: value), and "No active/current task" messages
-            if (trimmed &&
-                !trimmed.startsWith('#') &&
-                !trimmed.toLowerCase().includes('no active task') &&
-                !trimmed.toLowerCase().includes('no current task') &&
-                !trimmed.match(/^(Feature|Started|Status|Agent):/i) &&
-                !trimmed.startsWith('**') &&
-                !trimmed.startsWith('-')) {
-              currentTask = trimmed
-              break
-            }
-          }
-        }
-        // Truncate if too long
-        if (currentTask && currentTask.length > 60) {
-          currentTask = currentTask.substring(0, 57) + '...'
-        }
-      } catch {}
-
-      // Get session status and last activity
-      let hasActiveSession = false
-      let lastActivity: string | null = null
-
-      // Check for real PTY sessions (actual Claude sessions in memory)
-      try {
-        const activeSessions = listSessions()
-        hasActiveSession = activeSessions.some(s => s.projectDir === repoPath)
-      } catch {}
-
-      // Try current session for lastActivity only
-      try {
-        const sessionPath = join(storagePath, 'sessions', 'current.json')
-        const sessionData = JSON.parse(await fs.readFile(sessionPath, 'utf-8'))
-        lastActivity = sessionData.startedAt || sessionData.updatedAt
-      } catch {}
-
-      // If no session, get last modified time from key files
-      if (!lastActivity) {
-        const filesToCheck = [
-          join(storagePath, 'core', 'now.md'),
-          join(storagePath, 'core', 'next.md'),
-          join(storagePath, 'planning', 'ideas.md'),
-          join(storagePath, 'progress', 'shipped.md'),
-          join(storagePath, 'memory', 'context.jsonl'),
-          join(storagePath, 'CLAUDE.md')
-        ]
-
-        let latestMtime = 0
-        for (const filePath of filesToCheck) {
-          try {
-            const stat = await fs.stat(filePath)
-            if (stat.mtimeMs > latestMtime) {
-              latestMtime = stat.mtimeMs
-            }
-          } catch {}
-        }
-
-        if (latestMtime > 0) {
-          lastActivity = new Date(latestMtime).toISOString()
-        }
-      }
-
-      // Count ideas, next tasks, and shipped items
-      let ideasCount = 0
-      let nextTasksCount = 0
-      let shippedCount = 0
-      try {
-        const ideasContent = await fs.readFile(join(storagePath, 'planning', 'ideas.md'), 'utf-8')
-        ideasCount = (ideasContent.match(/^- /gm) || []).length
-      } catch {}
-      try {
-        const nextContent = await fs.readFile(join(storagePath, 'core', 'next.md'), 'utf-8')
-        nextTasksCount = (nextContent.match(/^- /gm) || []).length
-      } catch {}
-      try {
-        const shippedContent = await fs.readFile(join(storagePath, 'progress', 'shipped.md'), 'utf-8')
-        // Count shipped items: either "- **Name**" or "### Name" format
-        const bulletItems = (shippedContent.match(/^- \*\*/gm) || []).length
-        const headingItems = (shippedContent.match(/^### /gm) || []).length
-        shippedCount = bulletItems + headingItems
-      } catch {}
-
-      // Find favicon/icon in project repo
-      let iconPath: string | null = null
-      if (repoPath) {
-        const iconPatterns = [
-          'public/favicon.ico',
-          'public/favicon.svg',
-          'public/icon.svg',
-          'public/icon.png',
-          'public/logo.svg',
-          'public/logo.png',
-          'app/favicon.ico',
-          'app/icon.svg',
-          'app/icon.png',
-          'favicon.ico',
-          'favicon.svg'
-        ]
-        for (const pattern of iconPatterns) {
-          try {
-            const fullPath = join(repoPath, pattern)
-            await fs.access(fullPath)
-            iconPath = fullPath
-            break
-          } catch {}
-        }
-      }
-
-      projects.push({
-        id: projectId,
-        name,
-        path: repoPath || storagePath,
-        repoPath,
-        storagePath,
-        currentTask,
-        hasActiveSession,
-        lastActivity,
-        ideasCount,
-        nextTasksCount,
-        shippedCount,
-        techStack,
-        iconPath
-      })
-    }
-  } catch {
-    // Storage directory doesn't exist
-  }
-
-  // Sort by lastActivity (most recent first), then by name
-  projects.sort((a, b) => {
-    if (a.lastActivity && b.lastActivity) {
-      return new Date(b.lastActivity).getTime() - new Date(a.lastActivity).getTime()
-    }
-    if (a.lastActivity) return -1
-    if (b.lastActivity) return 1
-    return a.name.localeCompare(b.name)
-  })
-
-  return projects
-}
-
-/**
- * Get project by ID
- */
-export async function getProject(projectId: string) {
-  const storagePath = join(GLOBAL_STORAGE, projectId)
-
-  // 1. Try to read from project.json (source of truth for dashboard)
-  let repoPath: string | null = null
-  let name: string = projectId
-  let version: string | null = null
-  let stack: string | null = null
-  let filesCount: string | null = null
-  let commitsCount: string | null = null
-  let techStack: string[] = []
-
-  try {
-    const projectJsonPath = join(storagePath, 'project.json')
-    const projectJson = JSON.parse(await fs.readFile(projectJsonPath, 'utf-8'))
-    repoPath = projectJson.repoPath || null
-    name = projectJson.name || projectId
-    version = projectJson.version || null
-    stack = projectJson.stack || null
-    filesCount = projectJson.fileCount ? String(projectJson.fileCount) : null
-    commitsCount = projectJson.commitCount ? String(projectJson.commitCount) : null
-    techStack = projectJson.techStack || []
-  } catch {
-    // project.json doesn't exist - fallback to scan
-    if (projectPathCache.size === 0) {
-      await scanForProjects()
-    }
-    repoPath = projectPathCache.get(projectId) || null
-  }
-
-  try {
-    const claudeMd = await fs.readFile(join(storagePath, 'CLAUDE.md'), 'utf-8')
-
-    // If still no repoPath, try extracting from CLAUDE.md
-    if (!repoPath) {
-      repoPath = extractProjectPath(claudeMd)
-    }
-
-    // If name is still projectId, try CLAUDE.md
-    if (name === projectId) {
-      const nameMatch = claudeMd.match(/# (.+) - Project Context/)
-      if (nameMatch) name = nameMatch[1]
-    }
-
-    let currentSession = null
-    try {
-      const sessionPath = join(storagePath, 'sessions', 'current.json')
-      const sessionData = await fs.readFile(sessionPath, 'utf-8')
-      currentSession = JSON.parse(sessionData)
-    } catch {}
-
-    let currentTask = null
-    try {
-      const nowPath = join(storagePath, 'core', 'now.md')
-      currentTask = await fs.readFile(nowPath, 'utf-8')
-    } catch {}
-
-    // Count shipped and queue items (DRY - same logic as getProjects)
-    let shippedCount = 0
-    let nextTasksCount = 0
-    try {
-      const shippedContent = await fs.readFile(join(storagePath, 'progress', 'shipped.md'), 'utf-8')
-      const bulletItems = (shippedContent.match(/^- \*\*/gm) || []).length
-      const headingItems = (shippedContent.match(/^### /gm) || []).length
-      shippedCount = bulletItems + headingItems
-    } catch {}
-    try {
-      const nextContent = await fs.readFile(join(storagePath, 'core', 'next.md'), 'utf-8')
-      nextTasksCount = (nextContent.match(/^- /gm) || []).length
-    } catch {}
-
-    const total = shippedCount + nextTasksCount
-    const completionRate = total > 0 ? Math.round((shippedCount / total) * 100) : 0
-
-    // Fallback: Extract stats from claudeMd Quick Reference table if not from project.json
-    if (!version) {
-      const versionMatch = claudeMd.match(/\*\*Version\*\*\s*\|\s*([^\n|]+)/)
-      if (versionMatch) version = versionMatch[1].trim()
-    }
-
-    if (!stack) {
-      const stackMatch = claudeMd.match(/\*\*Stack\*\*\s*\|\s*([^\n|]+)/)
-      if (stackMatch) stack = stackMatch[1].trim()
-    }
-
-    if (!filesCount) {
-      const filesMatch = claudeMd.match(/\*\*Files\*\*\s*\|\s*([^\n|]+)/)
-      if (filesMatch) filesCount = filesMatch[1].trim()
-    }
-
-    if (!commitsCount) {
-      const commitsMatch = claudeMd.match(/\*\*Commits\*\*\s*\|\s*([^\n|]+)/)
-      if (commitsMatch) commitsCount = commitsMatch[1].trim()
-    }
-
-    // Find favicon/icon in project repo
-    let iconPath: string | null = null
-    if (repoPath) {
-      const iconPatterns = [
-        'public/favicon.ico',
-        'public/favicon.svg',
-        'public/icon.svg',
-        'public/icon.png',
-        'public/logo.svg',
-        'public/logo.png',
-        'app/favicon.ico',
-        'app/icon.svg',
-        'app/icon.png',
-        'favicon.ico',
-        'favicon.svg'
-      ]
-      for (const pattern of iconPatterns) {
-        try {
-          const fullPath = join(repoPath, pattern)
-          await fs.access(fullPath)
-          iconPath = fullPath
-          break
-        } catch {}
-      }
-    }
-
-    return {
-      id: projectId,
-      name,
-      path: storagePath, // Storage path (for prjct data)
-      repoPath, // Real repository path (for terminal/Claude)
-      storagePath,
-      claudeMd,
-      currentSession,
-      currentTask,
-      // Parsed stats
-      version,
-      stack,
-      filesCount,
-      commitsCount,
-      techStack,
-      iconPath,
-      // Counts (DRY - same source as dashboard)
-      shippedCount,
-      nextTasksCount,
-      completionRate
-    }
-  } catch {
-    return null
-  }
-}
-
-/**
- * Move project to trash (soft delete)
- */
-export async function moveToTrash(projectId: string) {
-  const sourcePath = join(GLOBAL_STORAGE, projectId)
-  const trashPath = join(TRASH_PATH, projectId)
-
-  // Verify source exists
-  try {
-    await fs.access(sourcePath)
-  } catch {
-    throw new Error(`Project ${projectId} not found`)
-  }
-
-  // Create trash directory if it doesn't exist
-  await fs.mkdir(TRASH_PATH, { recursive: true })
-
-  // Move to trash
-  await fs.rename(sourcePath, trashPath)
-
-  // Write deletion metadata
-  const deletedAt = new Date().toISOString()
-  await fs.writeFile(
-    join(trashPath, '.deleted'),
-    JSON.stringify({ deletedAt, projectId })
-  )
-
-  return { trashedAt: deletedAt }
-}
-
-/**
- * Get project status
- */
-export async function getProjectStatus(projectId: string) {
-  const projectPath = join(GLOBAL_STORAGE, projectId)
-
-  let session = null
-  let repoPath: string | null = null
-  try {
-    const sessionPath = join(projectPath, 'sessions', 'current.json')
-    session = JSON.parse(await fs.readFile(sessionPath, 'utf-8'))
-  } catch {}
-
-  // Get repoPath from project.json for PTY session check
-  try {
-    const projectJsonPath = join(projectPath, 'project.json')
-    const projectJson = JSON.parse(await fs.readFile(projectJsonPath, 'utf-8'))
-    repoPath = projectJson.repoPath || null
-  } catch {}
-
-  // Check for real PTY sessions
-  let hasActiveSession = false
-  if (repoPath) {
-    try {
-      const activeSessions = listSessions()
-      hasActiveSession = activeSessions.some(s => s.projectDir === repoPath)
-    } catch {}
-  }
-
-  let ideas: string[] = []
-  try {
-    const ideasPath = join(projectPath, 'planning', 'ideas.md')
-    const content = await fs.readFile(ideasPath, 'utf-8')
-    ideas = content.split('\n').filter(l => l.startsWith('- ')).slice(0, 5)
-  } catch {}
-
-  let nextTasks: string[] = []
-  try {
-    const nextPath = join(projectPath, 'core', 'next.md')
-    const content = await fs.readFile(nextPath, 'utf-8')
-    nextTasks = content.split('\n').filter(l => l.startsWith('- ')).slice(0, 5)
-  } catch {}
-
-  return {
-    projectId,
-    session,
-    hasActiveSession,
-    ideas,
-    nextTasks
-  }
-}

package/packages/web/lib/pty.ts

@@ -1,101 +0,0 @@
-/**
- * PTY Manager - Handle Claude Code CLI sessions via pseudo-terminal
- */
-
-import * as pty from 'node-pty'
-import type { IPty } from 'node-pty'
-
-interface Session {
-  pty: IPty
-  projectDir: string
-  createdAt: Date
-}
-
-const sessions = new Map<string, Session>()
-
-export function createClaudeSession(sessionId: string, projectDir: string): IPty {
-  // Kill existing session if any
-  const existing = sessions.get(sessionId)
-  if (existing) {
-    try {
-      existing.pty.kill()
-    } catch {
-      // Ignore
-    }
-    sessions.delete(sessionId)
-  }
-
-  // Spawn claude CLI
-  const shell = process.platform === 'win32' ? 'cmd.exe' : 'bash'
-  const args = process.platform === 'win32' ? [] : ['-l']
-
-  const ptyProcess = pty.spawn(shell, args, {
-    name: 'xterm-256color',
-    cols: 120,
-    rows: 30,
-    cwd: projectDir,
-    env: {
-      ...process.env,
-      TERM: 'xterm-256color',
-      COLORTERM: 'truecolor'
-    }
-  })
-
-  // Store session
-  sessions.set(sessionId, {
-    pty: ptyProcess,
-    projectDir,
-    createdAt: new Date()
-  })
-
-  // Auto-start Claude Code CLI
-  setTimeout(() => {
-    ptyProcess.write('claude\r')
-  }, 500)
-
-  return ptyProcess
-}
-
-export function getSession(sessionId: string): IPty | null {
-  const session = sessions.get(sessionId)
-  return session?.pty || null
-}
-
-export function killSession(sessionId: string): boolean {
-  const session = sessions.get(sessionId)
-  if (session) {
-    try {
-      session.pty.kill()
-    } catch {
-      // Ignore
-    }
-    sessions.delete(sessionId)
-    return true
-  }
-  return false
-}
-
-export function resizeSession(sessionId: string, cols: number, rows: number): boolean {
-  const session = sessions.get(sessionId)
-  if (session) {
-    try {
-      session.pty.resize(cols, rows)
-      return true
-    } catch {
-      return false
-    }
-  }
-  return false
-}
-
-export function listSessions(): { sessionId: string; projectDir: string; createdAt: Date }[] {
-  const result: { sessionId: string; projectDir: string; createdAt: Date }[] = []
-  sessions.forEach((session, sessionId) => {
-    result.push({
-      sessionId,
-      projectDir: session.projectDir,
-      createdAt: session.createdAt
-    })
-  })
-  return result
-}

package/packages/web/lib/query-config.ts

@@ -1,44 +0,0 @@
-import type { UseQueryOptions } from '@tanstack/react-query'
-
-// Refresh intervals in milliseconds
-export const REFRESH_INTERVALS = {
-  realtime: 2000,      // 2s - for active sessions, connection status
-  fast: 5000,          // 5s - for project status, current task
-  normal: 10000,       // 10s - for project list, stats
-  slow: 30000,         // 30s - for historical data
-} as const
-
-// Default query options for different data freshness needs
-export const queryPresets = {
-  // For data that needs to feel "live" (sessions, connection status)
-  realtime: {
-    staleTime: 0,
-    refetchInterval: REFRESH_INTERVALS.realtime,
-    refetchOnWindowFocus: true,
-    refetchOnReconnect: true,
-  },
-
-  // For frequently changing data (project status, tasks)
-  fast: {
-    staleTime: REFRESH_INTERVALS.fast / 2,
-    refetchInterval: REFRESH_INTERVALS.fast,
-    refetchOnWindowFocus: true,
-    refetchOnReconnect: true,
-  },
-
-  // For moderately changing data (project list, stats)
-  normal: {
-    staleTime: REFRESH_INTERVALS.normal / 2,
-    refetchInterval: REFRESH_INTERVALS.normal,
-    refetchOnWindowFocus: true,
-    refetchOnReconnect: true,
-  },
-
-  // For rarely changing data (settings, historical)
-  slow: {
-    staleTime: REFRESH_INTERVALS.slow / 2,
-    refetchInterval: REFRESH_INTERVALS.slow,
-    refetchOnWindowFocus: true,
-    refetchOnReconnect: false,
-  },
-} as const satisfies Record<string, Partial<UseQueryOptions>>