prjct-cli 0.44.1 → 0.45.3

package/core/services/sync-service.ts

@@ -15,21 +15,23 @@
  * @version 1.0.0
  */
 
-import fs from 'fs/promises'
-import path from 'path'
-import { exec } from 'child_process'
-import { promisify } from 'util'
-import pathManager from '../infrastructure/path-manager'
-import configManager from '../infrastructure/config-manager'
-import dateHelper from '../utils/date-helper'
+import { exec } from 'node:child_process'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { promisify } from 'node:util'
 import {
-  generateAIToolContexts,
   DEFAULT_AI_TOOLS,
-  resolveToolIds,
   detectInstalledTools,
+  generateAIToolContexts,
   type ProjectContext,
-  type GenerateResult,
+  resolveToolIds,
 } from '../ai-tools'
+import configManager from '../infrastructure/config-manager'
+import pathManager from '../infrastructure/path-manager'
+import { metricsStorage } from '../storage/metrics-storage'
+import dateHelper from '../utils/date-helper'
+import { ContextFileGenerator } from './context-generator'
+import { type StackDetection, StackDetector } from './stack-detector'
 
 const execAsync = promisify(exec)
 
@@ -69,16 +71,6 @@ interface Commands {
   format: string
 }
 
-interface StackDetection {
-  hasFrontend: boolean
-  hasBackend: boolean
-  hasDatabase: boolean
-  hasDocker: boolean
-  hasTesting: boolean
-  frontendType: 'web' | 'mobile' | 'both' | null
-  frameworks: string[]
-}
-
 interface AgentInfo {
   name: string
   type: 'workflow' | 'domain'
@@ -91,6 +83,13 @@ interface AIToolResult {
   success: boolean
 }
 
+interface SyncMetrics {
+  duration: number // Sync duration in ms
+  originalSize: number // Estimated tokens before compression
+  filteredSize: number // Actual tokens in context files
+  compressionRate: number // Percentage saved
+}
+
 interface SyncResult {
   success: boolean
   projectId: string
@@ -103,11 +102,12 @@ interface SyncResult {
   skills: { agent: string; skill: string }[]
   contextFiles: string[]
   aiTools: AIToolResult[]
+  syncMetrics?: SyncMetrics
   error?: string
 }
 
 interface SyncOptions {
-  aiTools?: string[]  // AI tools to generate context for (default: claude, cursor)
+  aiTools?: string[] // AI tools to generate context for (default: claude, cursor)
 }
 
 // ============================================================================
@@ -129,6 +129,7 @@ class SyncService {
    */
   async sync(projectPath: string = process.cwd(), options: SyncOptions = {}): Promise<SyncResult> {
     this.projectPath = projectPath
+    const startTime = Date.now()
 
     // Resolve AI tools: supports 'auto', 'all', or specific list
     let aiToolIds: string[]
@@ -166,16 +167,22 @@ class SyncService {
       this.globalPath = pathManager.getGlobalProjectPath(this.projectId)
       this.cliVersion = await this.getCliVersion()
 
-      // 2. Ensure directories exist
-      await this.ensureDirectories()
+      // 2. Ensure directories exist (non-blocking)
+      const ensureDirsPromise = this.ensureDirectories()
+
+      // 3. Gather all data IN PARALLEL (30-50% speedup)
+      // These operations are independent and can run concurrently
+      const [git, stats, commands, stack] = await Promise.all([
+        this.analyzeGit(),
+        this.gatherStats(),
+        this.detectCommands(),
+        this.detectStack(),
+      ])
 
-      // 3. Gather all data
-      const git = await this.analyzeGit()
-      const stats = await this.gatherStats()
-      const commands = await this.detectCommands()
-      const stack = await this.detectStack()
+      // Wait for directories before writing files
+      await ensureDirsPromise
 
-      // 4. Generate all files
+      // 4. Generate all files (depends on gathered data)
       const agents = await this.generateAgents(stack, stats)
       const skills = this.configureSkills(agents)
       const contextFiles = await this.generateContextFiles(git, stats, commands, agents)
@@ -196,8 +203,8 @@ class SyncService {
         hasChanges: git.hasChanges,
         commands,
         agents: {
-          workflow: agents.filter(a => a.type === 'workflow').map(a => a.name),
-          domain: agents.filter(a => a.type === 'domain').map(a => a.name),
+          workflow: agents.filter((a) => a.type === 'workflow').map((a) => a.name),
+          domain: agents.filter((a) => a.type === 'domain').map((a) => a.name),
         },
       }
 
@@ -208,14 +215,16 @@ class SyncService {
         aiToolIds
       )
 
-      // 6. Update project.json
-      await this.updateProjectJson(git, stats)
+      // 6-8. Update files IN PARALLEL (write to different files)
+      await Promise.all([
+        this.updateProjectJson(git, stats),
+        this.updateStateJson(stats, stack),
+        this.logToMemory(git, stats),
+      ])
 
-      // 7. Update state.json with enterprise fields
-      await this.updateStateJson(stats, stack)
-
-      // 8. Log to memory
-      await this.logToMemory(git, stats)
+      // 9. Record metrics for value dashboard
+      const duration = Date.now() - startTime
+      const syncMetrics = await this.recordSyncMetrics(stats, contextFiles, agents, duration)
 
       return {
         success: true,
@@ -228,11 +237,12 @@ class SyncService {
         agents,
         skills,
         contextFiles,
-        aiTools: aiToolResults.map(r => ({
+        aiTools: aiToolResults.map((r) => ({
           toolId: r.toolId,
           outputFile: r.outputFile,
           success: r.success,
         })),
+        syncMetrics,
       }
     } catch (error) {
       return {
@@ -258,9 +268,10 @@ class SyncService {
 
   private async ensureDirectories(): Promise<void> {
     const dirs = ['storage', 'context', 'agents', 'memory', 'analysis', 'config', 'sync']
-    for (const dir of dirs) {
-      await fs.mkdir(path.join(this.globalPath, dir), { recursive: true })
-    }
+    // Create all directories IN PARALLEL
+    await Promise.all(
+      dirs.map((dir) => fs.mkdir(path.join(this.globalPath, dir), { recursive: true }))
+    )
   }
 
   // ==========================================================================
@@ -291,13 +302,13 @@ class SyncService {
       const { stdout: commits } = await execAsync('git rev-list --count HEAD', {
         cwd: this.projectPath,
       })
-      data.commits = parseInt(commits.trim()) || 0
+      data.commits = parseInt(commits.trim(), 10) || 0
 
       // Contributors
       const { stdout: contributors } = await execAsync('git shortlog -sn --all | wc -l', {
         cwd: this.projectPath,
       })
-      data.contributors = parseInt(contributors.trim()) || 0
+      data.contributors = parseInt(contributors.trim(), 10) || 0
 
       // Status
       const { stdout: status } = await execAsync('git status --porcelain', {
@@ -335,7 +346,7 @@ class SyncService {
       const { stdout: weekly } = await execAsync('git log --oneline --since="1 week ago" | wc -l', {
         cwd: this.projectPath,
       })
-      data.weeklyCommits = parseInt(weekly.trim()) || 0
+      data.weeklyCommits = parseInt(weekly.trim(), 10) || 0
     } catch {
       // Not a git repo - use defaults
     }
@@ -364,7 +375,7 @@ class SyncService {
         'find . -type f \\( -name "*.js" -o -name "*.ts" -o -name "*.tsx" -o -name "*.py" -o -name "*.go" -o -name "*.rs" \\) -not -path "./node_modules/*" -not -path "./.git/*" | wc -l',
         { cwd: this.projectPath }
       )
-      stats.fileCount = parseInt(stdout.trim()) || 0
+      stats.fileCount = parseInt(stdout.trim(), 10) || 0
     } catch {
       stats.fileCount = 0
     }
@@ -407,7 +418,7 @@ class SyncService {
       stats.ecosystem = 'Go'
       stats.languages.push('Go')
     }
-    if (await this.fileExists('requirements.txt') || await this.fileExists('pyproject.toml')) {
+    if ((await this.fileExists('requirements.txt')) || (await this.fileExists('pyproject.toml'))) {
       stats.ecosystem = 'Python'
       stats.languages.push('Python')
     }
@@ -493,60 +504,8 @@ class SyncService {
   // ==========================================================================
 
   private async detectStack(): Promise<StackDetection> {
-    const stack: StackDetection = {
-      hasFrontend: false,
-      hasBackend: false,
-      hasDatabase: false,
-      hasDocker: false,
-      hasTesting: false,
-      frontendType: null,
-      frameworks: [],
-    }
-
-    try {
-      const pkgPath = path.join(this.projectPath, 'package.json')
-      const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf-8'))
-      const deps = { ...pkg.dependencies, ...pkg.devDependencies }
-
-      // Frontend detection
-      if (deps.react || deps.vue || deps.svelte || deps['@angular/core']) {
-        stack.hasFrontend = true
-        stack.frontendType = 'web'
-      }
-      if (deps['react-native'] || deps.expo) {
-        stack.hasFrontend = true
-        stack.frontendType = stack.frontendType === 'web' ? 'both' : 'mobile'
-      }
-
-      // Backend detection
-      if (deps.express || deps.fastify || deps.hono || deps.koa || deps.nest) {
-        stack.hasBackend = true
-      }
-
-      // Database detection
-      if (deps.prisma || deps.mongoose || deps.pg || deps.mysql2 || deps.sequelize) {
-        stack.hasDatabase = true
-      }
-
-      // Testing detection
-      if (deps.jest || deps.vitest || deps.mocha || pkg.devDependencies?.['bun-types']) {
-        stack.hasTesting = true
-      }
-
-      // Collect frameworks
-      if (deps.react) stack.frameworks.push('React')
-      if (deps.next) stack.frameworks.push('Next.js')
-      if (deps.express) stack.frameworks.push('Express')
-      if (deps.hono) stack.frameworks.push('Hono')
-    } catch {
-      // No package.json
-    }
-
-    // Docker detection
-    stack.hasDocker =
-      (await this.fileExists('Dockerfile')) || (await this.fileExists('docker-compose.yml'))
-
-    return stack
+    const detector = new StackDetector(this.projectPath)
+    return detector.detect()
   }
 
   // ==========================================================================
@@ -569,40 +528,43 @@ class SyncService {
       // Directory might not exist yet
     }
 
-    // Workflow agents (always generated)
+    // Workflow agents (always generated) - IN PARALLEL
     const workflowAgents = ['prjct-workflow', 'prjct-planner', 'prjct-shipper']
+    await Promise.all(workflowAgents.map((name) => this.generateWorkflowAgent(name, agentsPath)))
     for (const name of workflowAgents) {
-      await this.generateWorkflowAgent(name, agentsPath)
       agents.push({ name, type: 'workflow' })
     }
 
-    // Domain agents (based on stack)
-    if (stack.hasFrontend) {
-      await this.generateDomainAgent('frontend', agentsPath, stats, stack)
-      agents.push({ name: 'frontend', type: 'domain', skill: 'javascript-typescript' })
+    // Domain agents (based on stack) - COLLECT AND GENERATE IN PARALLEL
+    const domainAgentsToGenerate: { name: string; skill?: string }[] = []
 
-      await this.generateDomainAgent('uxui', agentsPath, stats, stack)
-      agents.push({ name: 'uxui', type: 'domain', skill: 'frontend-design' })
+    if (stack.hasFrontend) {
+      domainAgentsToGenerate.push({ name: 'frontend', skill: 'javascript-typescript' })
+      domainAgentsToGenerate.push({ name: 'uxui', skill: 'frontend-design' })
     }
-
     if (stack.hasBackend) {
-      await this.generateDomainAgent('backend', agentsPath, stats, stack)
-      agents.push({ name: 'backend', type: 'domain', skill: 'javascript-typescript' })
+      domainAgentsToGenerate.push({ name: 'backend', skill: 'javascript-typescript' })
     }
-
     if (stack.hasDatabase) {
-      await this.generateDomainAgent('database', agentsPath, stats, stack)
-      agents.push({ name: 'database', type: 'domain' })
+      domainAgentsToGenerate.push({ name: 'database' })
     }
-
     if (stack.hasTesting) {
-      await this.generateDomainAgent('testing', agentsPath, stats, stack)
-      agents.push({ name: 'testing', type: 'domain', skill: 'developer-kit' })
+      domainAgentsToGenerate.push({ name: 'testing', skill: 'developer-kit' })
     }
-
     if (stack.hasDocker) {
-      await this.generateDomainAgent('devops', agentsPath, stats, stack)
-      agents.push({ name: 'devops', type: 'domain', skill: 'developer-kit' })
+      domainAgentsToGenerate.push({ name: 'devops', skill: 'developer-kit' })
+    }
+
+    // Generate all domain agents IN PARALLEL
+    await Promise.all(
+      domainAgentsToGenerate.map((agent) =>
+        this.generateDomainAgent(agent.name, agentsPath, stats, stack)
+      )
+    )
+
+    // Add to agents list
+    for (const agent of domainAgentsToGenerate) {
+      agents.push({ name: agent.name, type: 'domain', skill: agent.skill })
     }
 
     return agents
@@ -761,212 +723,13 @@ You are the ${name} expert for this project. Apply best practices for the detect
     commands: Commands,
     agents: AgentInfo[]
   ): Promise<string[]> {
-    const contextPath = path.join(this.globalPath, 'context')
-    const files: string[] = []
-
-    // Generate CLAUDE.md
-    await this.generateClaudeMd(contextPath, git, stats, commands, agents)
-    files.push('context/CLAUDE.md')
-
-    // Generate now.md
-    await this.generateNowMd(contextPath)
-    files.push('context/now.md')
-
-    // Generate next.md
-    await this.generateNextMd(contextPath)
-    files.push('context/next.md')
-
-    // Generate ideas.md
-    await this.generateIdeasMd(contextPath)
-    files.push('context/ideas.md')
-
-    // Generate shipped.md
-    await this.generateShippedMd(contextPath)
-    files.push('context/shipped.md')
-
-    return files
-  }
-
-  private async generateClaudeMd(
-    contextPath: string,
-    git: GitData,
-    stats: ProjectStats,
-    commands: Commands,
-    agents: AgentInfo[]
-  ): Promise<void> {
-    const workflowAgents = agents.filter((a) => a.type === 'workflow').map((a) => a.name)
-    const domainAgents = agents.filter((a) => a.type === 'domain').map((a) => a.name)
-
-    const content = `# ${stats.name} - Project Rules
-<!-- projectId: ${this.projectId} -->
-<!-- Generated: ${dateHelper.getTimestamp()} -->
-<!-- Ecosystem: ${stats.ecosystem} | Type: ${stats.projectType} -->
-
-## THIS PROJECT (${stats.ecosystem})
-
-**Type:** ${stats.projectType}
-**Path:** ${this.projectPath}
-
-### Commands (USE THESE, NOT OTHERS)
-
-| Action | Command |
-|--------|---------|
-| Install dependencies | \`${commands.install}\` |
-| Run dev server | \`${commands.dev}\` |
-| Run tests | \`${commands.test}\` |
-| Build | \`${commands.build}\` |
-| Lint | \`${commands.lint}\` |
-| Format | \`${commands.format}\` |
-
-### Code Conventions
-
-- **Languages**: ${stats.languages.join(', ') || 'Not detected'}
-- **Frameworks**: ${stats.frameworks.join(', ') || 'Not detected'}
-
----
-
-## PRJCT RULES
-
-### Path Resolution
-**ALL prjct writes go to**: \`~/.prjct-cli/projects/${this.projectId}/\`
-- NEVER write to \`.prjct/\`
-- NEVER write to \`./\` for prjct data
-
-### Workflow
-\`\`\`
-p. sync → p. task "desc" → [work] → p. done → p. ship
-\`\`\`
-
-| Command | Action |
-|---------|--------|
-| \`p. sync\` | Re-analyze project |
-| \`p. task X\` | Start task |
-| \`p. done\` | Complete subtask |
-| \`p. ship X\` | Ship feature |
-
----
-
-## PROJECT STATE
-
-| Field | Value |
-|-------|-------|
-| Name | ${stats.name} |
-| Version | ${stats.version} |
-| Ecosystem | ${stats.ecosystem} |
-| Branch | ${git.branch} |
-| Files | ~${stats.fileCount} |
-| Commits | ${git.commits} |
-
----
-
-## AGENTS
-
-Load from \`~/.prjct-cli/projects/${this.projectId}/agents/\`:
-
-**Workflow**: ${workflowAgents.join(', ')}
-**Domain**: ${domainAgents.join(', ') || 'none'}
-`
-
-    await fs.writeFile(path.join(contextPath, 'CLAUDE.md'), content, 'utf-8')
-  }
-
-  private async generateNowMd(contextPath: string): Promise<void> {
-    // Read current task from state
-    let currentTask = null
-    try {
-      const statePath = path.join(this.globalPath, 'storage', 'state.json')
-      const state = JSON.parse(await fs.readFile(statePath, 'utf-8'))
-      currentTask = state.currentTask
-    } catch {
-      // No state file
-    }
-
-    const content = currentTask
-      ? `# NOW
-
-**${currentTask.description}**
-
-Started: ${currentTask.startedAt}
-${currentTask.branch ? `Branch: ${currentTask.branch.name}` : ''}
-`
-      : `# NOW
-
-_No active task_
-
-Use \`p. task "description"\` to start working.
-`
-
-    await fs.writeFile(path.join(contextPath, 'now.md'), content, 'utf-8')
-  }
-
-  private async generateNextMd(contextPath: string): Promise<void> {
-    let queue: { tasks: { description: string; priority?: string }[] } = { tasks: [] }
-    try {
-      const queuePath = path.join(this.globalPath, 'storage', 'queue.json')
-      queue = JSON.parse(await fs.readFile(queuePath, 'utf-8'))
-    } catch {
-      // No queue file
-    }
-
-    const content = `# NEXT
-
-${
-  queue.tasks.length > 0
-    ? queue.tasks.map((t, i) => `${i + 1}. ${t.description}${t.priority ? ` [${t.priority}]` : ''}`).join('\n')
-    : '_Empty queue_'
-}
-`
-
-    await fs.writeFile(path.join(contextPath, 'next.md'), content, 'utf-8')
-  }
-
-  private async generateIdeasMd(contextPath: string): Promise<void> {
-    let ideas: { ideas: { text: string; priority?: string }[] } = { ideas: [] }
-    try {
-      const ideasPath = path.join(this.globalPath, 'storage', 'ideas.json')
-      ideas = JSON.parse(await fs.readFile(ideasPath, 'utf-8'))
-    } catch {
-      // No ideas file
-    }
-
-    const content = `# IDEAS
-
-${
-  ideas.ideas.length > 0
-    ? ideas.ideas.map((i) => `- ${i.text}${i.priority ? ` [${i.priority}]` : ''}`).join('\n')
-    : '_No ideas captured yet_'
-}
-`
-
-    await fs.writeFile(path.join(contextPath, 'ideas.md'), content, 'utf-8')
-  }
-
-  private async generateShippedMd(contextPath: string): Promise<void> {
-    let shipped: { shipped: { name: string; version?: string; shippedAt: string }[] } = {
-      shipped: [],
-    }
-    try {
-      const shippedPath = path.join(this.globalPath, 'storage', 'shipped.json')
-      shipped = JSON.parse(await fs.readFile(shippedPath, 'utf-8'))
-    } catch {
-      // No shipped file
-    }
-
-    const content = `# SHIPPED 🚀
-
-${
-  shipped.shipped.length > 0
-    ? shipped.shipped
-        .slice(-10)
-        .map((s) => `- **${s.name}**${s.version ? ` v${s.version}` : ''} - ${s.shippedAt}`)
-        .join('\n')
-    : '_Nothing shipped yet_'
-}
-
-**Total shipped:** ${shipped.shipped.length}
-`
+    const generator = new ContextFileGenerator({
+      projectId: this.projectId!,
+      projectPath: this.projectPath,
+      globalPath: this.globalPath,
+    })
 
-    await fs.writeFile(path.join(contextPath, 'shipped.md'), content, 'utf-8')
+    return generator.generate({ branch: git.branch, commits: git.commits }, stats, commands, agents)
   }
 
   // ==========================================================================
@@ -1039,7 +802,7 @@ ${
     state.lastSync = dateHelper.getTimestamp()
     state.lastUpdated = dateHelper.getTimestamp()
     state.context = {
-      ...(state.context as Record<string, unknown> || {}),
+      ...((state.context as Record<string, unknown>) || {}),
       lastSession: dateHelper.getTimestamp(),
       lastAction: 'Synced project',
       nextAction: 'Run `p. task "description"` to start working',
@@ -1064,7 +827,85 @@ ${
       commitCount: git.commits,
     }
 
-    await fs.appendFile(memoryPath, JSON.stringify(event) + '\n', 'utf-8')
+    await fs.appendFile(memoryPath, `${JSON.stringify(event)}\n`, 'utf-8')
+  }
+
+  // ==========================================================================
+  // METRICS RECORDING
+  // ==========================================================================
+
+  /**
+   * Record sync metrics for the value dashboard
+   *
+   * Calculates token savings by comparing:
+   * - Original: Estimated tokens if we sent all source files
+   * - Filtered: Actual tokens in generated context files
+   *
+   * Token estimation: ~4 chars per token (industry standard)
+   */
+  private async recordSyncMetrics(
+    stats: ProjectStats,
+    contextFiles: string[],
+    agents: AgentInfo[],
+    duration: number
+  ): Promise<SyncMetrics> {
+    const CHARS_PER_TOKEN = 4
+
+    // Calculate filtered size (actual context files generated)
+    let filteredChars = 0
+    for (const file of contextFiles) {
+      try {
+        const filePath = path.join(this.globalPath, file)
+        const content = await fs.readFile(filePath, 'utf-8')
+        filteredChars += content.length
+      } catch {
+        // File might not exist, skip
+      }
+    }
+
+    // Also count agent files
+    for (const agent of agents) {
+      try {
+        const agentPath = path.join(this.globalPath, 'agents', `${agent.name}.md`)
+        const content = await fs.readFile(agentPath, 'utf-8')
+        filteredChars += content.length
+      } catch {
+        // Skip if not found
+      }
+    }
+
+    const filteredSize = Math.floor(filteredChars / CHARS_PER_TOKEN)
+
+    // Estimate original size (what it would take without prjct)
+    // Conservative estimate: avg 500 tokens per source file
+    // Plus overhead for manually creating context
+    const avgTokensPerFile = 500
+    const originalSize = stats.fileCount * avgTokensPerFile
+
+    // Calculate compression rate
+    const compressionRate =
+      originalSize > 0 ? Math.max(0, (originalSize - filteredSize) / originalSize) : 0
+
+    // Record to storage
+    try {
+      await metricsStorage.recordSync(this.projectId!, {
+        originalSize,
+        filteredSize,
+        duration,
+        isWatch: false,
+        agents: agents.filter((a) => a.type === 'domain').map((a) => a.name),
+      })
+    } catch (error) {
+      // Non-blocking - metrics are nice to have
+      console.error('Warning: Failed to record metrics:', (error as Error).message)
+    }
+
+    return {
+      duration,
+      originalSize,
+      filteredSize,
+      compressionRate,
+    }
   }
 
   // ==========================================================================
@@ -1144,4 +985,4 @@ ${
 }
 
 export const syncService = new SyncService()
-export { SyncService, SyncResult }
+export { SyncService, type SyncResult }