prjct-cli 0.11.4 → 0.12.0

package/bin/prjct

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 
 /**
  * prjct CLI entry point
@@ -6,8 +6,8 @@
  * Auto-setup on first use (like Astro, Vite, etc.)
  */
 
-const { VERSION } = require('../core/utils/version')
-const editorsConfig = require('../core/infrastructure/editors-config')
+const { VERSION } = require('../core/utils/version.ts')
+const editorsConfig = require('../core/infrastructure/editors-config.ts').default
 
 // Check for special subcommands that bypass normal CLI
 const args = process.argv.slice(2)
@@ -31,7 +31,7 @@ if (args[0] === 'dev') {
       console.log('🔧 One-time setup (v' + VERSION + ')...')
       console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n')
 
-      const setup = require('../core/infrastructure/setup')
+      const setup = require('../core/infrastructure/setup.ts').default
       await setup.run()
 
       console.log('✓ Setup complete!\n')
@@ -42,7 +42,7 @@ if (args[0] === 'dev') {
   }
 
   // Continue to main CLI logic
-  require('../core/index')
+  require('../core/index.ts')
 })()
 
 } // end else

package/bin/serve.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 
 /**
  * prjct serve - Start the web server
@@ -6,21 +6,26 @@
  * Launches the prjct web interface with Claude Code CLI integration.
  * Uses your existing Claude subscription via PTY - no API costs!
  *
- * Auto-installs dependencies on first run.
+ * Smart dependency management:
+ * - Tracks installed version in .prjct-web-state.json
+ * - Only installs when version changes or node_modules missing
+ * - Reuses existing prjct-web server if already running on port
  */
 
-const { spawn, spawnSync } = require('child_process')
+const { spawn, spawnSync, execSync } = require('child_process')
 const path = require('path')
 const fs = require('fs')
 
 const packagesDir = path.join(__dirname, '..', 'packages')
 const sharedDir = path.join(packagesDir, 'shared')
 const webDir = path.join(packagesDir, 'web')
+const prjctDir = path.join(require('os').homedir(), '.prjct-cli')
+const stateFile = path.join(prjctDir, '.prjct-web-state.json')
 
 // Parse arguments
 const args = process.argv.slice(2)
 const portArg = args.find((a) => a.startsWith('--port='))
-const port = portArg ? portArg.split('=')[1] : '3000'
+const port = portArg ? portArg.split('=')[1] : '9472'
 
 // Check if web package exists
 if (!fs.existsSync(webDir)) {
@@ -30,26 +35,123 @@ if (!fs.existsSync(webDir)) {
   process.exit(1)
 }
 
-// Check if dependencies are installed
-const sharedNodeModules = path.join(sharedDir, 'node_modules')
-const webNodeModules = path.join(webDir, 'node_modules')
-const needsSharedInstall = fs.existsSync(sharedDir) && !fs.existsSync(sharedNodeModules)
-const needsWebInstall = !fs.existsSync(webNodeModules)
+/**
+ * Read the current state file
+ */
+function readState() {
+  try {
+    if (fs.existsSync(stateFile)) {
+      return JSON.parse(fs.readFileSync(stateFile, 'utf8'))
+    }
+  } catch {
+    // Ignore errors, return empty state
+  }
+  return {}
+}
+
+/**
+ * Write state file
+ */
+function writeState(state) {
+  try {
+    // Ensure ~/.prjct-cli directory exists
+    if (!fs.existsSync(prjctDir)) {
+      fs.mkdirSync(prjctDir, { recursive: true })
+    }
+    fs.writeFileSync(stateFile, JSON.stringify(state, null, 2))
+  } catch {
+    // Ignore write errors
+  }
+}
+
+/**
+ * Get package.json version and hash of dependencies
+ */
+function getPackageInfo(pkgPath) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(pkgPath, 'package.json'), 'utf8'))
+    const deps = JSON.stringify(pkg.dependencies || {}) + JSON.stringify(pkg.devDependencies || {})
+    // Simple hash of dependencies
+    let hash = 0
+    for (let i = 0; i < deps.length; i++) {
+      const char = deps.charCodeAt(i)
+      hash = ((hash << 5) - hash) + char
+      hash = hash & hash // Convert to 32bit integer
+    }
+    return { version: pkg.version, depsHash: hash.toString(16) }
+  } catch {
+    return { version: '0.0.0', depsHash: '0' }
+  }
+}
+
+/**
+ * Check if dependencies need to be installed
+ */
+function needsInstall(pkgDir, stateKey) {
+  const nodeModules = path.join(pkgDir, 'node_modules')
+
+  // If node_modules doesn't exist, definitely need install
+  if (!fs.existsSync(nodeModules)) {
+    return { needed: true, reason: 'node_modules not found' }
+  }
+
+  const state = readState()
+  const pkgInfo = getPackageInfo(pkgDir)
+  const savedInfo = state[stateKey]
+
+  // If no saved state, need install to track
+  if (!savedInfo) {
+    return { needed: true, reason: 'first time tracking' }
+  }
+
+  // If version changed, need install
+  if (savedInfo.version !== pkgInfo.version) {
+    return { needed: true, reason: `version changed: ${savedInfo.version} → ${pkgInfo.version}` }
+  }
+
+  // If dependencies hash changed, need install
+  if (savedInfo.depsHash !== pkgInfo.depsHash) {
+    return { needed: true, reason: 'dependencies changed' }
+  }
+
+  return { needed: false }
+}
+
+/**
+ * Update state after successful install
+ */
+function markInstalled(pkgDir, stateKey) {
+  const state = readState()
+  const pkgInfo = getPackageInfo(pkgDir)
+  state[stateKey] = {
+    version: pkgInfo.version,
+    depsHash: pkgInfo.depsHash,
+    installedAt: new Date().toISOString()
+  }
+  writeState(state)
+}
+
+// Check if dependencies need installation
+const sharedCheck = fs.existsSync(sharedDir) ? needsInstall(sharedDir, 'shared') : { needed: false }
+const webCheck = needsInstall(webDir, 'web')
+
+if (sharedCheck.needed || webCheck.needed) {
+  const reasons = []
+  if (sharedCheck.needed) reasons.push(`shared: ${sharedCheck.reason}`)
+  if (webCheck.needed) reasons.push(`web: ${webCheck.reason}`)
 
-if (needsSharedInstall || needsWebInstall) {
   console.log(`
 ╔═══════════════════════════════════════════════════════════╗
 ║                                                           ║
-║   ⚡ prjct - First Time Setup                            ║
+║   ⚡ prjct - Dependency Update                           ║
 ║                                                           ║
-║   Installing web dependencies...                          ║
-║   This only happens once.                                 ║
+║   ${reasons.join(', ').substring(0, 45).padEnd(45)}       ║
 ║                                                           ║
 ╚═══════════════════════════════════════════════════════════╝
 `)
 
-  // Install shared dependencies first (if exists)
-  if (needsSharedInstall) {
+  // Install shared dependencies first (if needed)
+  if (sharedCheck.needed) {
     console.log('📦 Installing packages/shared dependencies...')
     const sharedInstall = spawnSync('npm', ['install'], {
       cwd: sharedDir,
@@ -73,10 +175,12 @@ if (needsSharedInstall || needsWebInstall) {
     if (sharedBuild.status !== 0) {
       console.error('⚠️  Warning: Failed to build shared package')
     }
+
+    markInstalled(sharedDir, 'shared')
   }
 
-  // Install web dependencies
-  if (needsWebInstall) {
+  // Install web dependencies (if needed)
+  if (webCheck.needed) {
     console.log('📦 Installing packages/web dependencies...')
     const webInstall = spawnSync('npm', ['install'], {
       cwd: webDir,
@@ -88,55 +192,133 @@ if (needsSharedInstall || needsWebInstall) {
       console.error('❌ Failed to install web dependencies')
       process.exit(1)
     }
+
+    markInstalled(webDir, 'web')
   }
 
-  console.log('✅ Dependencies installed!\n')
+  console.log('✅ Dependencies ready!\n')
+} else {
+  console.log('✅ Dependencies up to date\n')
+}
+
+/**
+ * Check if process on port is a prjct-web server
+ */
+function isPrjctWebProcess(pid) {
+  try {
+    if (process.platform === 'win32') {
+      const result = spawnSync('wmic', ['process', 'where', `processid=${pid}`, 'get', 'commandline'], {
+        shell: true,
+        encoding: 'utf8',
+      })
+      return result.stdout.includes('server.ts') || result.stdout.includes('prjct')
+    } else {
+      // macOS / Linux - check process command line
+      const result = spawnSync('ps', ['-p', pid, '-o', 'command='], {
+        shell: true,
+        encoding: 'utf8',
+      })
+      const cmd = result.stdout.trim()
+      return cmd.includes('server.ts') || cmd.includes('prjct') || cmd.includes('next')
+    }
+  } catch {
+    return false
+  }
 }
 
-// Kill any process using the port
-function killPort(portToKill) {
+/**
+ * Get PIDs using a port
+ */
+function getPortPids(portToCheck) {
   try {
     if (process.platform === 'win32') {
-      // Windows
       const result = spawnSync('netstat', ['-ano'], { shell: true, encoding: 'utf8' })
+      const pids = []
       const lines = result.stdout.split('\n')
       for (const line of lines) {
-        if (line.includes(`:${portToKill}`) && line.includes('LISTENING')) {
+        if (line.includes(`:${portToCheck}`) && line.includes('LISTENING')) {
           const parts = line.trim().split(/\s+/)
           const pid = parts[parts.length - 1]
-          if (pid && pid !== '0') {
-            spawnSync('taskkill', ['/F', '/PID', pid], { shell: true })
-          }
+          if (pid && pid !== '0') pids.push(pid)
         }
       }
+      return pids
     } else {
-      // macOS / Linux
-      const result = spawnSync('lsof', ['-ti', `:${portToKill}`], {
+      const result = spawnSync('lsof', ['-ti', `:${portToCheck}`], {
         shell: true,
         encoding: 'utf8',
       })
-      const pids = result.stdout.trim().split('\n').filter(Boolean)
-      for (const pid of pids) {
+      return result.stdout.trim().split('\n').filter(Boolean)
+    }
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Kill specific PIDs
+ */
+function killPids(pids) {
+  for (const pid of pids) {
+    try {
+      if (process.platform === 'win32') {
+        spawnSync('taskkill', ['/F', '/PID', pid], { shell: true })
+      } else {
         spawnSync('kill', ['-9', pid], { shell: true })
       }
+    } catch {
+      // Ignore individual kill errors
     }
-  } catch {
-    // Ignore errors - port might not be in use
   }
 }
 
-// Kill port if occupied
-const checkPort = spawnSync('lsof', ['-ti', `:${port}`], {
-  shell: true,
-  encoding: 'utf8',
-})
+/**
+ * Open URL in browser
+ */
+function openBrowser(url) {
+  const openCmd =
+    process.platform === 'darwin'
+      ? 'open'
+      : process.platform === 'win32'
+        ? 'start'
+        : 'xdg-open'
+  spawn(openCmd, [url], { shell: true, detached: true }).unref()
+}
+
+// Check if port is in use and handle accordingly
+const portPids = getPortPids(port)
+let serverAlreadyRunning = false
+
+if (portPids.length > 0) {
+  // Check if it's a prjct-web server
+  const isPrjctWeb = portPids.some(pid => isPrjctWebProcess(pid))
+
+  if (isPrjctWeb) {
+    console.log(`
+╔═══════════════════════════════════════════════════════════╗
+║                                                           ║
+║   ⚡ prjct - Server Already Running                      ║
+║                                                           ║
+║   Found existing prjct-web on port ${port}                 ║
+║   Opening browser...                                      ║
+║                                                           ║
+╚═══════════════════════════════════════════════════════════╝
+`)
+    openBrowser(`http://localhost:${port}`)
+    serverAlreadyRunning = true
+  } else {
+    // Not a prjct-web process, ask before killing
+    console.log(`⚠️  Port ${port} is in use by another process.`)
+    console.log(`   PIDs: ${portPids.join(', ')}`)
+    console.log(`   Stopping to avoid killing unrelated processes.`)
+    console.log(`   Use --port=XXXX to specify a different port.`)
+    process.exit(1)
+  }
+}
 
-if (checkPort.stdout.trim()) {
-  console.log(`⚠️  Port ${port} is in use. Killing existing process...`)
-  killPort(port)
-  // Small delay to ensure port is released
-  spawnSync('sleep', ['1'], { shell: true })
-  console.log(`✅ Port ${port} freed\n`)
+// If server is already running, we're done - just opened browser above
+if (serverAlreadyRunning) {
+  process.exit(0)
 }
 
 console.log(`
@@ -144,32 +326,42 @@ console.log(`
 ║                                                           ║
 ║   ⚡ prjct - Developer Momentum                          ║
 ║                                                           ║
-║   Starting web server...                                  ║
+║   Starting production server...                           ║
 ║                                                           ║
-║   Web:     http://localhost:${port}                          ║
+║   Web:     http://localhost:${port}                         ║
 ║                                                           ║
 ║   Using your Claude subscription - $0 API costs           ║
 ║                                                           ║
 ╚═══════════════════════════════════════════════════════════╝
 `)
 
-// Start web dev server
-const web = spawn('npm', ['run', 'dev'], {
+// Build for production if needed (first run or .next missing)
+const nextDir = path.join(webDir, '.next')
+if (!fs.existsSync(nextDir)) {
+  console.log('🔨 Building for production (first run)...\n')
+  const buildResult = spawnSync('npm', ['run', 'build'], {
+    cwd: webDir,
+    stdio: 'inherit',
+    shell: true,
+  })
+  if (buildResult.status !== 0) {
+    console.error('❌ Build failed')
+    process.exit(1)
+  }
+  console.log('✅ Build complete!\n')
+}
+
+// Start web server in production mode
+const web = spawn('npm', ['run', 'start:prod'], {
   cwd: webDir,
   stdio: 'inherit',
   shell: true,
-  env: { ...process.env, PORT: port },
+  env: { ...process.env, PORT: port, NODE_ENV: 'production' },
 })
 
 // Open browser after a short delay
 setTimeout(() => {
-  const openCmd =
-    process.platform === 'darwin'
-      ? 'open'
-      : process.platform === 'win32'
-        ? 'start'
-        : 'xdg-open'
-  spawn(openCmd, [`http://localhost:${port}`], { shell: true })
+  openBrowser(`http://localhost:${port}`)
 }, 3000)
 
 // Handle shutdown

package/core/__tests__/agentic/{memory-system.test.js → memory-system.test.ts}

@@ -3,27 +3,21 @@
  * P3.3: Semantic Memory Database
  */
 
-const memorySystem = require('../../agentic/memory-system')
-const fs = require('fs').promises
-const path = require('path')
-const os = require('os')
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
+import memorySystem from '../../agentic/memory-system'
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
 
-// Generate unique project ID for each test run
 let testCounter = 0
 const getTestProjectId = () => `test-memory-${Date.now()}-${++testCounter}`
 
 describe('MemorySystem P3.3', () => {
-  let TEST_PROJECT_ID
+  let TEST_PROJECT_ID: string
 
   beforeEach(() => {
-    // Use unique project ID for each test to avoid data leakage
     TEST_PROJECT_ID = getTestProjectId()
-    // Reset internal state
-    memorySystem._memories = null
-    memorySystem._memoriesLoaded = false
-    memorySystem._patterns = null
-    memorySystem._patternsLoaded = false
-    memorySystem._sessionMemory.clear()
+    memorySystem.resetState()
   })
 
   describe('createMemory', () => {
@@ -64,10 +58,10 @@ describe('MemorySystem P3.3', () => {
       const memories = await memorySystem.getAllMemories(TEST_PROJECT_ID)
       const memory = memories.find(m => m.id === memoryId)
 
-      expect(memory.title).toBe('Updated Title')
-      expect(memory.content).toBe('Updated content')
-      expect(memory.tags).toContain('architecture')
-      expect(memory.tags).not.toContain('code_style')
+      expect(memory!.title).toBe('Updated Title')
+      expect(memory!.content).toBe('Updated content')
+      expect(memory!.tags).toContain('architecture')
+      expect(memory!.tags).not.toContain('code_style')
     })
 
     it('should return false for non-existent memory', async () => {
@@ -96,7 +90,6 @@ describe('MemorySystem P3.3', () => {
 
   describe('findByTags', () => {
     beforeEach(async () => {
-      // Create test memories
       await memorySystem.createMemory(TEST_PROJECT_ID, {
         title: 'Memory 1',
         content: 'Content 1',
@@ -160,7 +153,6 @@ describe('MemorySystem P3.3', () => {
 
   describe('getRelevantMemories', () => {
     beforeEach(async () => {
-      // Create memories with different relevance
       await memorySystem.createMemory(TEST_PROJECT_ID, {
         title: 'Commit Style',
         content: 'Use conventional commits',
@@ -184,7 +176,6 @@ describe('MemorySystem P3.3', () => {
       const results = await memorySystem.getRelevantMemories(TEST_PROJECT_ID, context, 5)
 
       expect(results.length).toBeGreaterThan(0)
-      // Ship command should prioritize commit_style and ship_workflow tags
       const hasRelevantTags = results.some(m =>
         m.tags.includes('commit_style') || m.tags.includes('ship_workflow')
       )
@@ -195,9 +186,8 @@ describe('MemorySystem P3.3', () => {
       const context = { commandName: 'ship', params: {} }
       const results = await memorySystem.getRelevantMemories(TEST_PROJECT_ID, context, 5)
 
-      // User triggered should be ranked higher
       const userTriggeredIndex = results.findIndex(m => m.userTriggered)
-      expect(userTriggeredIndex).toBeLessThanOrEqual(1) // Should be in top 2
+      expect(userTriggeredIndex).toBeLessThanOrEqual(1)
     })
 
     it('should limit results', async () => {
@@ -251,7 +241,6 @@ describe('MemorySystem P3.3', () => {
     })
   })
 
-  // Cleanup test directories after each test
   afterEach(async () => {
     try {
       const testPath = path.join(os.homedir(), '.prjct-cli', 'projects', TEST_PROJECT_ID)

package/core/__tests__/agentic/{plan-mode.test.js → plan-mode.test.ts}

@@ -3,14 +3,18 @@
  * P3.4: Plan Mode + Approval Flow
  */
 
-const planMode = require('../../agentic/plan-mode')
-const { PLAN_STATUS, PLAN_REQUIRED_COMMANDS, DESTRUCTIVE_COMMANDS, PLANNING_TOOLS } = require('../../agentic/plan-mode')
+import { describe, it, expect, beforeEach } from 'bun:test'
+import planMode, {
+  PLAN_STATUS,
+  PLAN_REQUIRED_COMMANDS,
+  DESTRUCTIVE_COMMANDS,
+  PLANNING_TOOLS
+} from '../../agentic/plan-mode'
 
 describe('PlanMode P3.4', () => {
   const TEST_PROJECT_ID = 'test-plan-mode'
 
   beforeEach(() => {
-    // Clear any active plans
     planMode.activePlans.clear()
   })
 
@@ -136,8 +140,8 @@ describe('PlanMode P3.4', () => {
       planMode.recordGatheredInfo(TEST_PROJECT_ID, { type: 'file', source: 'src/index.js', data: 'content' })
 
       const plan = planMode.getActivePlan(TEST_PROJECT_ID)
-      expect(plan.gatheredInfo.length).toBe(1)
-      expect(plan.gatheredInfo[0].type).toBe('file')
+      expect(plan!.gatheredInfo.length).toBe(1)
+      expect(plan!.gatheredInfo[0].type).toBe('file')
     })
   })
 
@@ -151,7 +155,7 @@ describe('PlanMode P3.4', () => {
       })
 
       const plan = planMode.getActivePlan(TEST_PROJECT_ID)
-      expect(plan.status).toBe(PLAN_STATUS.PENDING_APPROVAL)
+      expect(plan!.status).toBe(PLAN_STATUS.PENDING_APPROVAL)
     })
 
     it('should return formatted plan for display', () => {
@@ -162,9 +166,9 @@ describe('PlanMode P3.4', () => {
         steps: [{ description: 'Step 1' }]
       })
 
-      expect(formatted.summary).toBe('Test plan')
-      expect(formatted.approach).toBe('Test approach')
-      expect(formatted.requiresConfirmation).toBe(true)
+      expect(formatted!.summary).toBe('Test plan')
+      expect(formatted!.approach).toBe('Test approach')
+      expect(formatted!.requiresConfirmation).toBe(true)
     })
   })
 
@@ -174,9 +178,9 @@ describe('PlanMode P3.4', () => {
       planMode.proposePlan(TEST_PROJECT_ID, { steps: [{ description: 'Step 1' }] })
       const result = planMode.approvePlan(TEST_PROJECT_ID)
 
-      expect(result.approved).toBe(true)
+      expect(result!.approved).toBe(true)
       const plan = planMode.getActivePlan(TEST_PROJECT_ID)
-      expect(plan.status).toBe(PLAN_STATUS.APPROVED)
+      expect(plan!.status).toBe(PLAN_STATUS.APPROVED)
     })
 
     it('should convert proposed steps to executable steps', () => {
@@ -186,13 +190,12 @@ describe('PlanMode P3.4', () => {
       })
       const result = planMode.approvePlan(TEST_PROJECT_ID)
 
-      expect(result.steps.length).toBe(2)
-      expect(result.steps[0].status).toBe('pending')
+      expect(result!.steps.length).toBe(2)
+      expect(result!.steps[0].status).toBe('pending')
     })
 
     it('should return null if not pending approval', () => {
       planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
-      // Not proposed yet, so should return null
       const result = planMode.approvePlan(TEST_PROJECT_ID)
 
       expect(result).toBeNull()
@@ -205,8 +208,8 @@ describe('PlanMode P3.4', () => {
       planMode.proposePlan(TEST_PROJECT_ID, { steps: [] })
       const result = planMode.rejectPlan(TEST_PROJECT_ID, 'Not the right approach')
 
-      expect(result.rejected).toBe(true)
-      expect(result.reason).toBe('Not the right approach')
+      expect(result!.rejected).toBe(true)
+      expect(result!.reason).toBe('Not the right approach')
     })
 
     it('should clear active plan after rejection', () => {
@@ -233,17 +236,17 @@ describe('PlanMode P3.4', () => {
     it('should start execution and return first step', () => {
       const step = planMode.startExecution(TEST_PROJECT_ID)
 
-      expect(step.stepNumber).toBe(1)
-      expect(step.totalSteps).toBe(2)
-      expect(step.progress).toBe(0)
+      expect(step!.stepNumber).toBe(1)
+      expect(step!.totalSteps).toBe(2)
+      expect(step!.progress).toBe(0)
     })
 
     it('should advance to next step on completion', () => {
       planMode.startExecution(TEST_PROJECT_ID)
       const nextStep = planMode.completeStep(TEST_PROJECT_ID, { success: true })
 
-      expect(nextStep.stepNumber).toBe(2)
-      expect(nextStep.progress).toBe(50)
+      expect(nextStep!.stepNumber).toBe(2)
+      expect(nextStep!.progress).toBe(50)
     })
 
     it('should complete plan when all steps done', () => {
@@ -251,7 +254,6 @@ describe('PlanMode P3.4', () => {
       planMode.completeStep(TEST_PROJECT_ID)
       const result = planMode.completeStep(TEST_PROJECT_ID)
 
-      // When all steps complete, getNextStep returns null and completePlan is called
       expect(result).toBeNull()
       expect(planMode.getActivePlan(TEST_PROJECT_ID)).toBeNull()
     })
@@ -266,8 +268,8 @@ describe('PlanMode P3.4', () => {
 
       const result = planMode.abortPlan(TEST_PROJECT_ID, 'User cancelled')
 
-      expect(result.aborted).toBe(true)
-      expect(result.reason).toBe('User cancelled')
+      expect(result!.aborted).toBe(true)
+      expect(result!.reason).toBe('User cancelled')
       expect(planMode.getActivePlan(TEST_PROJECT_ID)).toBeNull()
     })
   })