prjct-cli 0.10.14 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.11.0] - 2025-12-08
+
+### Added - Web Application & Server Components
+
+Major release introducing the prjct web application with Next.js.
+
+- **Web Application** - Full Next.js web interface for prjct
+  - Project stats API implementation
+  - Enhanced UI components
+  - Terminal functionality in browser
+
+- **Server Components** - New server infrastructure
+  - Project management endpoints
+  - Stats API for metrics and analytics
+
+- **UI Enhancements**
+  - Improved project management interface
+  - Enhanced terminal integration
+
 ## [0.10.14] - 2025-11-29
 
 ### Refactored - 100% Agentic Subagent Delegation via Task Tool

package/bin/dev.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+
+/**
+ * prjct dev - Start prjct web development environment
+ *
+ * Launches Next.js fullstack app on port 9472
+ * - Frontend + API routes + WebSocket for PTY
+ *
+ * Usage: prjct dev [--no-open]
+ */
+
+const { spawn, exec } = require('child_process')
+const path = require('path')
+const os = require('os')
+
+// Configuration
+const PORT = process.env.PRJCT_PORT || 9472
+const WEB_URL = `http://localhost:${PORT}`
+
+// Colors for terminal output
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  magenta: '\x1b[35m'
+}
+
+// Find prjct-cli root (where packages/ lives)
+function findPrjctRoot() {
+  const locations = [
+    path.join(__dirname, '..'),
+    path.join(os.homedir(), 'Apps', 'prjct', 'prjct-cli'),
+    path.join(os.homedir(), '.prjct-cli', 'source'),
+  ]
+
+  for (const loc of locations) {
+    const pkgPath = path.join(loc, 'packages')
+    try {
+      require('fs').accessSync(pkgPath)
+      return loc
+    } catch {}
+  }
+
+  return locations[0]
+}
+
+const PRJCT_ROOT = findPrjctRoot()
+const WEB_PATH = path.join(PRJCT_ROOT, 'packages', 'web')
+
+// Print banner
+function printBanner() {
+  console.log(`
+${colors.cyan}${colors.bright}╔═══════════════════════════════════════════════╗
+║                                               ║
+║   ⚡ prjct dev                                 ║
+║                                               ║
+║   App:     ${colors.green}http://localhost:${PORT}${colors.cyan}            ║
+║                                               ║
+║   ${colors.dim}Press Ctrl+C to stop${colors.cyan}${colors.bright}                        ║
+║                                               ║
+╚═══════════════════════════════════════════════╝${colors.reset}
+`)
+}
+
+// Open browser based on OS
+function openBrowser(url) {
+  const platform = os.platform()
+  let command
+
+  switch (platform) {
+    case 'darwin':
+      command = `open "${url}"`
+      break
+    case 'win32':
+      command = `start "" "${url}"`
+      break
+    default:
+      command = `xdg-open "${url}"`
+  }
+
+  exec(command, (err) => {
+    if (err) {
+      console.log(`${colors.yellow}Could not open browser automatically. Visit: ${url}${colors.reset}`)
+    }
+  })
+}
+
+// Check if port is available
+function checkPort(port) {
+  return new Promise((resolve) => {
+    const net = require('net')
+    const server = net.createServer()
+
+    server.once('error', () => resolve(false))
+    server.once('listening', () => {
+      server.close()
+      resolve(true)
+    })
+
+    server.listen(port)
+  })
+}
+
+// Wait for server to be ready
+function waitForServer(port, maxAttempts = 60) {
+  return new Promise((resolve, reject) => {
+    let attempts = 0
+
+    const check = () => {
+      const http = require('http')
+      const req = http.get(`http://localhost:${port}`, (res) => {
+        resolve(true)
+      })
+
+      req.on('error', () => {
+        attempts++
+        if (attempts >= maxAttempts) {
+          reject(new Error(`Server on port ${port} did not start`))
+        } else {
+          setTimeout(check, 500)
+        }
+      })
+
+      req.end()
+    }
+
+    check()
+  })
+}
+
+// Main function
+async function main() {
+  const args = process.argv.slice(2)
+  const noOpen = args.includes('--no-open')
+
+  // Check port
+  const portAvailable = await checkPort(PORT)
+
+  if (!portAvailable) {
+    console.log(`${colors.red}Port ${PORT} is already in use. Stop other services or set PRJCT_PORT.${colors.reset}`)
+    process.exit(1)
+  }
+
+  printBanner()
+
+  // Start Next.js with custom server
+  console.log(`${colors.cyan}Starting prjct...${colors.reset}`)
+  const webProc = spawn('npm', ['run', 'dev'], {
+    cwd: WEB_PATH,
+    env: { ...process.env, PORT: PORT.toString() },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    shell: true
+  })
+
+  webProc.stdout.on('data', (data) => {
+    const lines = data.toString().split('\n').filter(Boolean)
+    lines.forEach(line => {
+      // Show relevant output
+      if (line.includes('ready') || line.includes('Ready') || line.includes('[WS]')) {
+        console.log(`${colors.green}${line}${colors.reset}`)
+      } else if (!line.includes('╔') && !line.includes('║') && !line.includes('╚')) {
+        console.log(`${colors.dim}${line}${colors.reset}`)
+      }
+    })
+  })
+
+  webProc.stderr.on('data', (data) => {
+    const msg = data.toString().trim()
+    // Filter out common non-error messages
+    if (!msg.includes('ExperimentalWarning') && !msg.includes('punycode')) {
+      console.log(`${colors.red}${msg}${colors.reset}`)
+    }
+  })
+
+  // Wait for server and open browser
+  try {
+    console.log(`${colors.dim}Waiting for server to start...${colors.reset}`)
+    await waitForServer(PORT)
+
+    console.log(`${colors.green}${colors.bright}Ready!${colors.reset}\n`)
+
+    if (!noOpen) {
+      setTimeout(() => openBrowser(WEB_URL), 500)
+    }
+  } catch (err) {
+    console.log(`${colors.red}${err.message}${colors.reset}`)
+  }
+
+  // Handle shutdown
+  const cleanup = () => {
+    console.log(`\n${colors.yellow}Shutting down...${colors.reset}`)
+    webProc.kill()
+    process.exit(0)
+  }
+
+  process.on('SIGINT', cleanup)
+  process.on('SIGTERM', cleanup)
+
+  webProc.on('error', (err) => {
+    console.log(`${colors.red}Error: ${err.message}${colors.reset}`)
+  })
+
+  webProc.on('exit', (code) => {
+    if (code !== 0 && code !== null) {
+      console.log(`${colors.red}Exited with code ${code}${colors.reset}`)
+    }
+  })
+}
+
+main().catch((err) => {
+  console.error(`${colors.red}Error: ${err.message}${colors.reset}`)
+  process.exit(1)
+})

package/bin/prjct

@@ -9,6 +9,14 @@
 const { VERSION } = require('../core/utils/version')
 const editorsConfig = require('../core/infrastructure/editors-config')
 
+// Check for special subcommands that bypass normal CLI
+const args = process.argv.slice(2)
+if (args[0] === 'dev') {
+  // Launch prjct dev environment
+  require('./dev.js')
+  process.exitCode = 0
+} else {
+
 // Ensure setup has run for this version
 ;(async function ensureSetup() {
   try {
@@ -32,3 +40,5 @@ const editorsConfig = require('../core/infrastructure/editors-config')
   // Continue to main CLI logic
   require('../core/index')
 })()
+
+} // end else

package/bin/serve.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+/**
+ * prjct serve - Start the web server
+ *
+ * Launches the prjct web interface with Claude Code CLI integration.
+ * Uses your existing Claude subscription via PTY - no API costs!
+ */
+
+const { spawn } = require('child_process')
+const path = require('path')
+const fs = require('fs')
+
+const serverDir = path.join(__dirname, '..', 'packages', 'server')
+const webDir = path.join(__dirname, '..', 'packages', 'web')
+
+// Parse arguments
+const args = process.argv.slice(2)
+const portArg = args.find(a => a.startsWith('--port='))
+const port = portArg ? portArg.split('=')[1] : '3333'
+const webPort = '3000'
+
+// Check if packages exist
+if (!fs.existsSync(serverDir) || !fs.existsSync(webDir)) {
+  console.error('❌ Web packages not found. Run from prjct-cli directory.')
+  process.exit(1)
+}
+
+console.log(`
+╔═══════════════════════════════════════════════════════════╗
+║                                                           ║
+║   ⚡ prjct - Developer Momentum                          ║
+║                                                           ║
+║   Starting web server...                                  ║
+║                                                           ║
+║   API:     http://localhost:${port}                          ║
+║   Web:     http://localhost:${webPort}                          ║
+║   Claude:  ws://localhost:${port}/ws/claude                  ║
+║                                                           ║
+║   Using your Claude subscription - $0 API costs           ║
+║                                                           ║
+╚═══════════════════════════════════════════════════════════╝
+`)
+
+// Start server
+const server = spawn('npm', ['run', 'dev'], {
+  cwd: serverDir,
+  stdio: 'inherit',
+  shell: true,
+  env: { ...process.env, PORT: port }
+})
+
+// Start web dev server
+const web = spawn('npm', ['run', 'dev'], {
+  cwd: webDir,
+  stdio: 'inherit',
+  shell: true
+})
+
+// Handle shutdown
+const cleanup = () => {
+  console.log('\n👋 Shutting down prjct server...')
+  server.kill()
+  web.kill()
+  process.exit(0)
+}
+
+process.on('SIGINT', cleanup)
+process.on('SIGTERM', cleanup)
+
+// Handle errors
+server.on('error', (err) => {
+  console.error('Server error:', err.message)
+})
+
+web.on('error', (err) => {
+  console.error('Web error:', err.message)
+})

package/core/bus/index.js

@@ -0,0 +1,322 @@
+/**
+ * EventBus - Lightweight Pub/Sub System for prjct-cli
+ *
+ * Simple event bus for decoupled communication between components.
+ * Supports sync/async listeners, wildcards, and one-time subscriptions.
+ *
+ * @version 1.0.0
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+const pathManager = require('../infrastructure/path-manager')
+
+/**
+ * Event Types - All events that can be emitted
+ */
+const EventTypes = {
+  // Session events
+  SESSION_STARTED: 'session.started',
+  SESSION_PAUSED: 'session.paused',
+  SESSION_RESUMED: 'session.resumed',
+  SESSION_COMPLETED: 'session.completed',
+
+  // Task events
+  TASK_CREATED: 'task.created',
+  TASK_COMPLETED: 'task.completed',
+  TASK_UPDATED: 'task.updated',
+
+  // Feature events
+  FEATURE_ADDED: 'feature.added',
+  FEATURE_SHIPPED: 'feature.shipped',
+  FEATURE_UPDATED: 'feature.updated',
+
+  // Idea events
+  IDEA_CAPTURED: 'idea.captured',
+  IDEA_PROMOTED: 'idea.promoted',
+
+  // Snapshot events
+  SNAPSHOT_CREATED: 'snapshot.created',
+  SNAPSHOT_RESTORED: 'snapshot.restored',
+
+  // Git events
+  COMMIT_CREATED: 'git.commit',
+  PUSH_COMPLETED: 'git.push',
+
+  // System events
+  PROJECT_INITIALIZED: 'project.init',
+  PROJECT_SYNCED: 'project.sync',
+  ANALYSIS_COMPLETED: 'analysis.completed',
+
+  // Wildcard
+  ALL: '*'
+}
+
+class EventBus {
+  constructor() {
+    this.listeners = new Map()
+    this.onceListeners = new Map()
+    this.history = []
+    this.historyLimit = 100
+    this.projectId = null
+  }
+
+  /**
+   * Initialize event bus for a project
+   * @param {string} projectId
+   */
+  async initialize(projectId) {
+    this.projectId = projectId
+  }
+
+  /**
+   * Subscribe to an event
+   * @param {string} event - Event type or wildcard pattern
+   * @param {Function} callback - Handler function
+   * @returns {Function} Unsubscribe function
+   */
+  on(event, callback) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set())
+    }
+    this.listeners.get(event).add(callback)
+
+    // Return unsubscribe function
+    return () => this.off(event, callback)
+  }
+
+  /**
+   * Subscribe to an event once
+   * @param {string} event
+   * @param {Function} callback
+   * @returns {Function} Unsubscribe function
+   */
+  once(event, callback) {
+    if (!this.onceListeners.has(event)) {
+      this.onceListeners.set(event, new Set())
+    }
+    this.onceListeners.get(event).add(callback)
+
+    return () => {
+      const listeners = this.onceListeners.get(event)
+      if (listeners) {
+        listeners.delete(callback)
+      }
+    }
+  }
+
+  /**
+   * Unsubscribe from an event
+   * @param {string} event
+   * @param {Function} callback
+   */
+  off(event, callback) {
+    const listeners = this.listeners.get(event)
+    if (listeners) {
+      listeners.delete(callback)
+    }
+  }
+
+  /**
+   * Emit an event
+   * @param {string} event - Event type
+   * @param {Object} data - Event payload
+   * @returns {Promise<void>}
+   */
+  async emit(event, data = {}) {
+    const timestamp = new Date().toISOString()
+    const eventData = {
+      type: event,
+      timestamp,
+      projectId: this.projectId,
+      ...data
+    }
+
+    // Store in history
+    this.history.push(eventData)
+    if (this.history.length > this.historyLimit) {
+      this.history.shift()
+    }
+
+    // Log event if project initialized
+    if (this.projectId) {
+      await this.logEvent(eventData)
+    }
+
+    // Get all matching listeners
+    const callbacks = this.getMatchingListeners(event)
+
+    // Execute all callbacks
+    const results = await Promise.allSettled(
+      callbacks.map(cb => this.executeCallback(cb, eventData))
+    )
+
+    // Log any errors
+    results.forEach((result, index) => {
+      if (result.status === 'rejected') {
+        console.error(`Event listener error for ${event}:`, result.reason)
+      }
+    })
+
+    // Handle once listeners
+    const onceCallbacks = this.onceListeners.get(event)
+    if (onceCallbacks) {
+      for (const cb of onceCallbacks) {
+        await this.executeCallback(cb, eventData)
+      }
+      this.onceListeners.delete(event)
+    }
+
+    // Also trigger wildcard once listeners
+    const wildcardOnce = this.onceListeners.get(EventTypes.ALL)
+    if (wildcardOnce) {
+      for (const cb of wildcardOnce) {
+        await this.executeCallback(cb, eventData)
+      }
+      // Don't delete wildcard once - only for specific events
+    }
+  }
+
+  /**
+   * Get all listeners that match an event (including wildcards)
+   * @param {string} event
+   * @returns {Function[]}
+   */
+  getMatchingListeners(event) {
+    const callbacks = []
+
+    // Exact match
+    const exact = this.listeners.get(event)
+    if (exact) {
+      callbacks.push(...exact)
+    }
+
+    // Wildcard match (*)
+    const wildcard = this.listeners.get(EventTypes.ALL)
+    if (wildcard) {
+      callbacks.push(...wildcard)
+    }
+
+    // Namespace wildcard (e.g., 'session.*' matches 'session.started')
+    const namespace = event.split('.')[0]
+    const namespaceWildcard = this.listeners.get(`${namespace}.*`)
+    if (namespaceWildcard) {
+      callbacks.push(...namespaceWildcard)
+    }
+
+    return callbacks
+  }
+
+  /**
+   * Execute a callback safely (handles sync and async)
+   * @param {Function} callback
+   * @param {Object} data
+   */
+  async executeCallback(callback, data) {
+    try {
+      const result = callback(data)
+      if (result instanceof Promise) {
+        await result
+      }
+    } catch (error) {
+      console.error('Event callback error:', error)
+      throw error
+    }
+  }
+
+  /**
+   * Log event to persistent storage
+   * @param {Object} eventData
+   */
+  async logEvent(eventData) {
+    try {
+      const globalPath = pathManager.getGlobalProjectPath(this.projectId)
+      const eventsPath = path.join(globalPath, 'memory', 'events.jsonl')
+
+      // Ensure directory exists
+      await fs.mkdir(path.dirname(eventsPath), { recursive: true })
+
+      // Append event
+      const line = JSON.stringify(eventData) + '\n'
+      await fs.appendFile(eventsPath, line)
+    } catch {
+      // Silently fail - logging should not break functionality
+    }
+  }
+
+  /**
+   * Get recent events from history
+   * @param {number} limit
+   * @param {string} [type] - Optional filter by event type
+   * @returns {Object[]}
+   */
+  getHistory(limit = 10, type = null) {
+    let events = this.history
+    if (type) {
+      events = events.filter(e => e.type === type || e.type.startsWith(type))
+    }
+    return events.slice(-limit)
+  }
+
+  /**
+   * Clear all listeners
+   */
+  clear() {
+    this.listeners.clear()
+    this.onceListeners.clear()
+  }
+
+  /**
+   * Get count of listeners for an event
+   * @param {string} event
+   * @returns {number}
+   */
+  listenerCount(event) {
+    const listeners = this.listeners.get(event)
+    return listeners ? listeners.size : 0
+  }
+
+  /**
+   * Get all registered event types
+   * @returns {string[]}
+   */
+  getRegisteredEvents() {
+    return Array.from(this.listeners.keys())
+  }
+}
+
+// Singleton instance
+const eventBus = new EventBus()
+
+// Convenience methods for common events
+const emit = {
+  sessionStarted: (data) => eventBus.emit(EventTypes.SESSION_STARTED, data),
+  sessionPaused: (data) => eventBus.emit(EventTypes.SESSION_PAUSED, data),
+  sessionResumed: (data) => eventBus.emit(EventTypes.SESSION_RESUMED, data),
+  sessionCompleted: (data) => eventBus.emit(EventTypes.SESSION_COMPLETED, data),
+
+  taskCreated: (data) => eventBus.emit(EventTypes.TASK_CREATED, data),
+  taskCompleted: (data) => eventBus.emit(EventTypes.TASK_COMPLETED, data),
+
+  featureAdded: (data) => eventBus.emit(EventTypes.FEATURE_ADDED, data),
+  featureShipped: (data) => eventBus.emit(EventTypes.FEATURE_SHIPPED, data),
+
+  ideaCaptured: (data) => eventBus.emit(EventTypes.IDEA_CAPTURED, data),
+
+  snapshotCreated: (data) => eventBus.emit(EventTypes.SNAPSHOT_CREATED, data),
+  snapshotRestored: (data) => eventBus.emit(EventTypes.SNAPSHOT_RESTORED, data),
+
+  commitCreated: (data) => eventBus.emit(EventTypes.COMMIT_CREATED, data),
+  pushCompleted: (data) => eventBus.emit(EventTypes.PUSH_COMPLETED, data),
+
+  projectInitialized: (data) => eventBus.emit(EventTypes.PROJECT_INITIALIZED, data),
+  projectSynced: (data) => eventBus.emit(EventTypes.PROJECT_SYNCED, data),
+  analysisCompleted: (data) => eventBus.emit(EventTypes.ANALYSIS_COMPLETED, data)
+}
+
+module.exports = {
+  EventBus,
+  EventTypes,
+  eventBus,
+  emit
+}