prjct-cli 1.22.0 → 1.24.0

package/core/domain/context-estimator.ts

@@ -1,175 +0,0 @@
-/**
- * ContextEstimator - Pre-filter files before building context
- *
- * Estimates which files are needed based on task analysis
- * BEFORE building full context - saves I/O
- *
- * @version 1.0.0
- */
-
-import { glob } from 'glob'
-import { getErrorMessage } from '../types/fs'
-import log from '../utils/logger'
-
-interface TaskAnalysis {
-  primaryDomain: string
-  projectTechnologies?: ProjectTech
-  semantic?: SemanticAnalysis
-}
-
-interface ProjectTech {
-  extensions?: Record<string, number>
-  directories?: string[]
-  [key: string]: unknown
-}
-
-interface SemanticAnalysis {
-  requiresMultipleAgents?: boolean
-  agents?: string[]
-  [key: string]: unknown
-}
-
-interface FilePatterns {
-  include: string[]
-  extensions: string[]
-  exclude: string[]
-}
-
-class ContextEstimator {
-  /**
-   * Estimate which files are needed for a task
-   */
-  async estimateFiles(taskAnalysis: TaskAnalysis, projectPath: string): Promise<string[]> {
-    const domain = taskAnalysis.primaryDomain
-    const projectTech = taskAnalysis.projectTechnologies || {}
-    const semantic = taskAnalysis.semantic || {}
-
-    // Get patterns for this domain
-    const patterns = this.getPatternsForDomain(domain, projectTech)
-
-    // Expand with semantic understanding
-    if (semantic.requiresMultipleAgents && semantic.agents) {
-      // Multi-agent task - combine patterns
-      const allPatterns = semantic.agents.reduce(
-        (acc, agentDomain) => {
-          const agentPatterns = this.getPatternsForDomain(agentDomain, projectTech)
-          return {
-            include: [...acc.include, ...agentPatterns.include],
-            extensions: [...acc.extensions, ...agentPatterns.extensions],
-          }
-        },
-        { include: [] as string[], extensions: [] as string[] }
-      )
-
-      patterns.include = [...new Set(allPatterns.include)]
-      patterns.extensions = [...new Set(allPatterns.extensions)]
-    }
-
-    // Find files matching patterns
-    const files = await this.findMatchingFiles(projectPath, patterns)
-
-    // Limit to reasonable number
-    const maxFiles = 200
-    return files.slice(0, maxFiles)
-  }
-
-  /**
-   * Get file patterns for a domain
-   *
-   * 100% AGENTIC: Uses REAL project data, not hardcoded patterns.
-   * No domain-specific assumptions or language→extension mapping.
-   */
-  getPatternsForDomain(_domain: string, projectData: ProjectTech): FilePatterns {
-    const patterns: FilePatterns = {
-      include: [],
-      extensions: [],
-      exclude: ['node_modules', 'dist', 'build', '.git', '.next', 'target', 'vendor', 'coverage'],
-    }
-
-    // Use REAL extensions from project (if provided in projectData)
-    if (projectData?.extensions) {
-      // projectData.extensions is {'.js': 45, '.ts': 23, ...}
-      patterns.extensions = Object.keys(projectData.extensions)
-        .filter((ext) => ext.startsWith('.'))
-        .slice(0, 15) // Top 15 extensions
-    }
-
-    // Use REAL directories from project (if provided in projectData)
-    if (projectData?.directories) {
-      patterns.include = projectData.directories.filter((dir) => !patterns.exclude.includes(dir))
-    }
-
-    // If no real data available, use minimal universal fallback
-    if (patterns.extensions.length === 0) {
-      patterns.extensions = ['*'] // All files
-    }
-
-    if (patterns.include.length === 0) {
-      patterns.include = ['.'] // Root directory
-    }
-
-    // NO domain-specific hardcoding
-    // Claude decides what files matter based on actual analysis
-
-    return patterns
-  }
-
-  /**
-   * Find files matching patterns
-   */
-  async findMatchingFiles(projectPath: string, patterns: FilePatterns): Promise<string[]> {
-    const files: string[] = []
-
-    try {
-      // Build glob patterns
-      const globPatterns: string[] = []
-
-      // Add include patterns
-      for (const include of patterns.include) {
-        for (const ext of patterns.extensions) {
-          globPatterns.push(`${include}/**/*${ext}`)
-          globPatterns.push(`**/${include}/**/*${ext}`)
-        }
-      }
-
-      // Also search root level
-      for (const ext of patterns.extensions) {
-        globPatterns.push(`*${ext}`)
-      }
-
-      // Execute glob searches
-      for (const pattern of globPatterns) {
-        try {
-          const matches = await glob(pattern, {
-            cwd: projectPath,
-            ignore: patterns.exclude.map((ex) => `**/${ex}/**`),
-            nodir: true,
-            follow: false,
-          })
-
-          if (Array.isArray(matches)) {
-            files.push(...matches)
-          }
-        } catch (_error) {
-          // Skip invalid patterns
-        }
-      }
-
-      // Remove duplicates and sort
-      return [...new Set(files)].sort()
-    } catch (error) {
-      log.error('Error finding files:', getErrorMessage(error))
-      return []
-    }
-  }
-
-  /**
-   * Estimate context size (number of files)
-   */
-  async estimateContextSize(taskAnalysis: TaskAnalysis, projectPath: string): Promise<number> {
-    const files = await this.estimateFiles(taskAnalysis, projectPath)
-    return files.length
-  }
-}
-
-export default ContextEstimator

package/core/domain/fibonacci.ts

@@ -1,128 +0,0 @@
-/**
- * Fibonacci Estimation Module
- *
- * Provides Fibonacci-based story point estimation with
- * points-to-time conversion and historical suggestion.
- */
-
-import outcomeRecorder from '../outcomes/recorder'
-
-// =============================================================================
-// Constants
-// =============================================================================
-
-/** Valid Fibonacci story points */
-export const FIBONACCI_POINTS = [1, 2, 3, 5, 8, 13, 21] as const
-export type FibonacciPoint = (typeof FIBONACCI_POINTS)[number]
-
-/** Default points-to-minutes mapping */
-const DEFAULT_MINUTES_MAP: Record<FibonacciPoint, { min: number; max: number; typical: number }> = {
-  1: { min: 5, max: 15, typical: 10 },
-  2: { min: 15, max: 30, typical: 20 },
-  3: { min: 30, max: 60, typical: 45 },
-  5: { min: 60, max: 120, typical: 90 },
-  8: { min: 120, max: 240, typical: 180 },
-  13: { min: 240, max: 480, typical: 360 },
-  21: { min: 480, max: 960, typical: 720 },
-}
-
-// =============================================================================
-// Validation
-// =============================================================================
-
-/** Check if a number is a valid Fibonacci point */
-export const isValidPoint = (n: number): n is FibonacciPoint =>
-  FIBONACCI_POINTS.includes(n as FibonacciPoint)
-
-// =============================================================================
-// Points-to-Time Conversion
-// =============================================================================
-
-/** Get the time range for a given point value */
-export const pointsToMinutes = (
-  points: FibonacciPoint
-): { min: number; max: number; typical: number } => {
-  return DEFAULT_MINUTES_MAP[points]
-}
-
-/** Format a minute count as a human-readable duration */
-export const formatMinutes = (minutes: number): string => {
-  if (minutes < 60) return `${minutes}m`
-  const hours = Math.floor(minutes / 60)
-  const mins = minutes % 60
-  return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`
-}
-
-/** Get a human-readable time range for a point value */
-export const pointsToTimeRange = (points: FibonacciPoint): string => {
-  const range = pointsToMinutes(points)
-  return `${formatMinutes(range.min)}–${formatMinutes(range.max)}`
-}
-
-// =============================================================================
-// Historical Suggestion
-// =============================================================================
-
-/**
- * Suggest a point estimate based on historical outcomes for similar task types.
- * Returns null if not enough data (< 3 outcomes).
- */
-export const suggestFromHistory = async (
-  projectId: string,
-  taskType: string
-): Promise<{ points: FibonacciPoint; basedOn: number } | null> => {
-  const outcomes = await outcomeRecorder.getAll(projectId)
-
-  // Filter by task type tag
-  const relevant = outcomes.filter((o) => o.tags?.includes(taskType))
-
-  if (relevant.length < 3) return null
-
-  // Calculate average actual duration in minutes
-  const totalMinutes = relevant.reduce((sum, o) => {
-    return sum + parseDuration(o.actualDuration)
-  }, 0)
-  const avgMinutes = totalMinutes / relevant.length
-
-  // Find closest Fibonacci point by typical time
-  const closest = findClosestPoint(avgMinutes)
-
-  return { points: closest, basedOn: relevant.length }
-}
-
-// =============================================================================
-// Helpers
-// =============================================================================
-
-/** Find the Fibonacci point whose typical time is closest to the given minutes */
-export const findClosestPoint = (minutes: number): FibonacciPoint => {
-  let closest: FibonacciPoint = 1
-  let smallestDiff = Number.POSITIVE_INFINITY
-
-  for (const point of FIBONACCI_POINTS) {
-    const diff = Math.abs(DEFAULT_MINUTES_MAP[point].typical - minutes)
-    if (diff < smallestDiff) {
-      smallestDiff = diff
-      closest = point
-    }
-  }
-
-  return closest
-}
-
-/** Parse a duration string like "2h 30m" to minutes */
-const parseDuration = (duration: string): number => {
-  let minutes = 0
-
-  const hourMatch = duration.match(/(\d+)h/)
-  if (hourMatch) {
-    minutes += Number.parseInt(hourMatch[1], 10) * 60
-  }
-
-  const minMatch = duration.match(/(\d+)m/)
-  if (minMatch) {
-    minutes += Number.parseInt(minMatch[1], 10)
-  }
-
-  return minutes
-}

package/core/domain/file-hasher.ts

@@ -1,296 +0,0 @@
-/**
- * File Hasher — Fast Content Hashing with SQLite Registry
- *
- * Computes content hashes for all project files and stores them in SQLite.
- * On subsequent syncs, compares current hashes against stored hashes
- * to identify added, modified, and deleted files.
- *
- * Uses Bun.hash (xxHash) for speed — <100ms for 500 files.
- *
- * @module domain/file-hasher
- * @version 1.0.0
- */
-
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import prjctDb from '../storage/database'
-
-// =============================================================================
-// Types
-// =============================================================================
-
-export interface FileHash {
-  path: string
-  hash: string
-  size: number
-  mtime: string
-}
-
-export interface FileDiff {
-  added: string[]
-  modified: string[]
-  deleted: string[]
-  unchanged: string[]
-}
-
-export interface HashRegistry {
-  files: Map<string, FileHash>
-  builtAt: string
-}
-
-// =============================================================================
-// Constants
-// =============================================================================
-
-const INDEXABLE_EXTENSIONS = new Set([
-  '.ts',
-  '.tsx',
-  '.js',
-  '.jsx',
-  '.mjs',
-  '.cjs',
-  '.json',
-  '.md',
-  '.css',
-  '.scss',
-  '.html',
-  '.vue',
-  '.svelte',
-  '.py',
-  '.go',
-  '.rs',
-  '.yaml',
-  '.yml',
-  '.toml',
-])
-
-const SKIP_DIRS = new Set([
-  'node_modules',
-  '.git',
-  'dist',
-  'build',
-  'out',
-  '.next',
-  'coverage',
-  '.cache',
-  '.turbo',
-  '.vercel',
-  '.prjct',
-])
-
-// =============================================================================
-// File Discovery
-// =============================================================================
-
-async function listProjectFiles(dir: string, projectPath: string): Promise<string[]> {
-  const files: string[] = []
-  const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => [])
-
-  for (const entry of entries) {
-    const name = String(entry.name)
-    if (SKIP_DIRS.has(name)) continue
-    if (name.startsWith('.') && name !== '.env.example') continue
-
-    const fullPath = path.join(dir, name)
-    if (entry.isDirectory()) {
-      files.push(...(await listProjectFiles(fullPath, projectPath)))
-    } else if (entry.isFile()) {
-      const ext = path.extname(name).toLowerCase()
-      if (INDEXABLE_EXTENSIONS.has(ext)) {
-        files.push(path.relative(projectPath, fullPath))
-      }
-    }
-  }
-  return files
-}
-
-// =============================================================================
-// Hashing
-// =============================================================================
-
-/**
- * Compute a fast hash of file content using Bun.hash (xxHash64).
- * Falls back to a simple checksum if Bun.hash is unavailable.
- */
-function hashContent(content: string): string {
-  // Bun.hash returns a bigint (xxHash64) — extremely fast
-  if (typeof Bun !== 'undefined' && Bun.hash) {
-    return `xxh64:${Bun.hash(content).toString(36)}`
-  }
-  // Fallback: simple FNV-1a 32-bit hash (still fast, no crypto overhead)
-  let h = 0x811c9dc5
-  for (let i = 0; i < content.length; i++) {
-    h ^= content.charCodeAt(i)
-    h = Math.imul(h, 0x01000193)
-  }
-  return `fnv1a:${(h >>> 0).toString(36)}`
-}
-
-/**
- * Compute hashes for all project files.
- * Processes files in parallel batches for speed.
- *
- * Performance target: <100ms for 500 files.
- */
-export async function computeHashes(projectPath: string): Promise<Map<string, FileHash>> {
-  const filePaths = await listProjectFiles(projectPath, projectPath)
-  const hashes = new Map<string, FileHash>()
-
-  const BATCH_SIZE = 100
-  for (let i = 0; i < filePaths.length; i += BATCH_SIZE) {
-    const batch = filePaths.slice(i, i + BATCH_SIZE)
-    const results = await Promise.all(
-      batch.map(async (filePath) => {
-        try {
-          const fullPath = path.join(projectPath, filePath)
-          const [content, stat] = await Promise.all([
-            fs.readFile(fullPath, 'utf-8'),
-            fs.stat(fullPath),
-          ])
-          return {
-            path: filePath,
-            hash: hashContent(content),
-            size: stat.size,
-            mtime: stat.mtime.toISOString(),
-          } satisfies FileHash
-        } catch {
-          return null
-        }
-      })
-    )
-
-    for (const result of results) {
-      if (result) {
-        hashes.set(result.path, result)
-      }
-    }
-  }
-
-  return hashes
-}
-
-// =============================================================================
-// Diff Detection
-// =============================================================================
-
-/**
- * Compare current file hashes against stored registry.
- * Returns lists of added, modified, deleted, and unchanged files.
- */
-export function diffHashes(
-  current: Map<string, FileHash>,
-  stored: Map<string, FileHash>
-): FileDiff {
-  const added: string[] = []
-  const modified: string[] = []
-  const unchanged: string[] = []
-
-  for (const [filePath, currentHash] of current) {
-    const storedHash = stored.get(filePath)
-    if (!storedHash) {
-      added.push(filePath)
-    } else if (storedHash.hash !== currentHash.hash) {
-      modified.push(filePath)
-    } else {
-      unchanged.push(filePath)
-    }
-  }
-
-  const deleted: string[] = []
-  for (const filePath of stored.keys()) {
-    if (!current.has(filePath)) {
-      deleted.push(filePath)
-    }
-  }
-
-  return { added, modified, deleted, unchanged }
-}
-
-// =============================================================================
-// SQLite Persistence (uses index_checksums table)
-// =============================================================================
-
-/**
- * Save file hashes to SQLite index_checksums table.
- */
-export function saveHashes(projectId: string, hashes: Map<string, FileHash>): void {
-  const db = prjctDb.getDb(projectId)
-
-  db.transaction(() => {
-    // Clear existing checksums
-    db.prepare('DELETE FROM index_checksums').run()
-
-    // Insert all hashes
-    const insert = db.prepare(
-      'INSERT INTO index_checksums (path, checksum, size, mtime) VALUES (?, ?, ?, ?)'
-    )
-
-    for (const [, hash] of hashes) {
-      insert.run(hash.path, hash.hash, hash.size, hash.mtime)
-    }
-  })()
-
-  // Also store metadata about when hashes were computed
-  prjctDb.setDoc(projectId, 'file-hashes-meta', {
-    fileCount: hashes.size,
-    builtAt: new Date().toISOString(),
-  })
-}
-
-/**
- * Load file hashes from SQLite index_checksums table.
- */
-export function loadHashes(projectId: string): Map<string, FileHash> {
-  const hashes = new Map<string, FileHash>()
-
-  try {
-    const rows = prjctDb.query<{ path: string; checksum: string; size: number; mtime: string }>(
-      projectId,
-      'SELECT path, checksum, size, mtime FROM index_checksums'
-    )
-
-    for (const row of rows) {
-      hashes.set(row.path, {
-        path: row.path,
-        hash: row.checksum,
-        size: row.size || 0,
-        mtime: row.mtime || '',
-      })
-    }
-  } catch {
-    // Table might not exist yet or be empty
-  }
-
-  return hashes
-}
-
-// =============================================================================
-// High-level API
-// =============================================================================
-
-/**
- * Compute file hashes and diff against stored registry.
- * Returns the diff and the current hashes (for saving after sync completes).
- *
- * If no stored hashes exist (first sync), all files are "added".
- */
-export async function detectChanges(
-  projectPath: string,
-  projectId: string
-): Promise<{ diff: FileDiff; currentHashes: Map<string, FileHash> }> {
-  const [currentHashes, storedHashes] = await Promise.all([
-    computeHashes(projectPath),
-    Promise.resolve(loadHashes(projectId)),
-  ])
-
-  const diff = diffHashes(currentHashes, storedHashes)
-
-  return { diff, currentHashes }
-}
-
-/**
- * Check if a hash registry exists for this project.
- */
-export function hasHashRegistry(projectId: string): boolean {
-  return prjctDb.hasDoc(projectId, 'file-hashes-meta')
-}