prjct-cli 1.22.0 → 1.23.0

package/core/agentic/smart-context.ts

@@ -1,393 +0,0 @@
-/**
- * Smart Context Compression
- *
- * Intelligently filters context based on task type.
- * Reduces prompt size by 40-70% while maintaining relevance.
- *
- * Uses LLM-based domain classification (PRJ-299) instead of keyword matching.
- *
- * @module agentic/smart-context
- * @version 2.0
- */
-
-import { agentPerformanceTracker } from '../agents'
-import { hasIndexes, rankFiles } from '../domain/file-ranker'
-import { outcomeAnalyzer } from '../outcomes'
-import type {
-  ContextDomain,
-  DomainAnalysis,
-  FilteredContext,
-  FullContext,
-  SmartContextProjectState,
-  StackInfo,
-  TaskType,
-} from '../types'
-import domainClassifier, { classifyWithHeuristic, type ProjectContext } from './domain-classifier'
-
-// Re-export types for convenience
-export type {
-  AgentInfo,
-  ContextDomain,
-  FeatureInfo,
-  FilteredContext,
-  FilterMetrics,
-  FullContext,
-  PatternInfo,
-  StackInfo,
-} from '../types'
-
-// Type alias exported for backward compatibility (used by external consumers)
-export type ProjectState = SmartContextProjectState
-
-// Map ClassificationDomain → ContextDomain
-function toContextDomain(domain: string): ContextDomain {
-  const mapping: Record<string, ContextDomain> = {
-    frontend: 'frontend',
-    backend: 'backend',
-    database: 'backend', // database maps to backend context domain
-    devops: 'devops',
-    testing: 'testing',
-    docs: 'docs',
-    uxui: 'frontend', // uxui maps to frontend context domain
-    general: 'general',
-  }
-  return mapping[domain] || 'general'
-}
-
-/**
- * SmartContext - Intelligent context filtering.
- */
-class SmartContext {
-  /**
-   * Detect the domain of a task from its description.
-   *
-   * Synchronous version using the improved heuristic (word-boundary matching).
-   * For full LLM-based classification, use classifyDomain().
-   */
-  detectDomain(taskDescription: string): DomainAnalysis {
-    // Default context when no project info is available
-    const defaultContext: ProjectContext = {
-      domains: {
-        hasFrontend: true,
-        hasBackend: true,
-        hasDatabase: true,
-        hasTesting: true,
-        hasDocker: true,
-      },
-      agents: [],
-    }
-
-    const result = classifyWithHeuristic(taskDescription, defaultContext)
-
-    return {
-      primary: toContextDomain(result.primaryDomain),
-      secondary: result.secondaryDomains.map(toContextDomain),
-      confidence: result.confidence,
-    }
-  }
-
-  /**
-   * Classify domain using the full fallback chain (cache → history → LLM → heuristic).
-   * Async version that leverages project context and LLM classification.
-   */
-  async classifyDomain(
-    taskDescription: string,
-    projectId: string,
-    globalPath: string,
-    context: ProjectContext
-  ): Promise<DomainAnalysis & { source: string }> {
-    const { classification, source } = await domainClassifier.classify(
-      taskDescription,
-      projectId,
-      globalPath,
-      context
-    )
-
-    return {
-      primary: toContextDomain(classification.primaryDomain),
-      secondary: classification.secondaryDomains.map(toContextDomain),
-      confidence: classification.confidence,
-      source,
-    }
-  }
-
-  /**
-   * Filter context for a specific task type.
-   */
-  async filterForTask(
-    fullContext: FullContext,
-    taskDescription: string,
-    projectId: string
-  ): Promise<FilteredContext> {
-    const domainAnalysis = this.detectDomain(taskDescription)
-    const { primary: taskDomain, secondary } = domainAnalysis
-
-    // Include primary and secondary domains
-    const relevantDomains = [taskDomain, ...secondary, 'general']
-
-    // Filter agents
-    const filteredAgents = fullContext.agents.filter((agent) =>
-      relevantDomains.includes(agent.domain)
-    )
-
-    // Enrich with performance data
-    for (const agent of filteredAgents) {
-      const perf = await agentPerformanceTracker.getAgentPerformance(projectId, agent.name)
-      if (perf) {
-        agent.successRate = perf.successRate
-      }
-    }
-
-    // Filter roadmap
-    const filteredRoadmap = fullContext.roadmap.filter((feature) =>
-      feature.relatedTo.some((domain) => relevantDomains.includes(domain))
-    )
-
-    // Filter patterns
-    const filteredPatterns = fullContext.patterns.filter((pattern) =>
-      relevantDomains.includes(pattern.domain)
-    )
-
-    // Get relevant patterns from outcomes
-    try {
-      const outcomePatterns = await outcomeAnalyzer.detectPatterns(projectId)
-      for (const pattern of outcomePatterns.slice(0, 3)) {
-        filteredPatterns.push({
-          description: pattern.description,
-          domain: taskDomain,
-          confidence: pattern.confidence,
-        })
-      }
-    } catch (_error) {
-      // Outcomes not available
-    }
-
-    // Filter stack
-    const filteredStack: Partial<StackInfo> = {}
-    if (relevantDomains.includes('frontend')) {
-      filteredStack.frontend = fullContext.stack.frontend
-    }
-    if (relevantDomains.includes('backend')) {
-      filteredStack.backend = fullContext.stack.backend
-      filteredStack.database = fullContext.stack.database
-    }
-    if (relevantDomains.includes('devops')) {
-      filteredStack.devops = fullContext.stack.devops
-    }
-    if (relevantDomains.includes('testing')) {
-      filteredStack.testing = fullContext.stack.testing
-    }
-
-    // Filter files: use BM25 ranker if indexes exist, else fall back to domain patterns
-    const filteredFiles = this.rankOrFilterFiles(
-      fullContext.files,
-      taskDescription,
-      projectId,
-      taskDomain
-    )
-
-    // Calculate metrics
-    const originalSize = this.estimateSize(fullContext)
-    const filteredSize = this.estimateSize({
-      agents: filteredAgents,
-      roadmap: filteredRoadmap,
-      patterns: filteredPatterns,
-      stack: filteredStack,
-      files: filteredFiles,
-    })
-
-    return {
-      agents: filteredAgents,
-      roadmap: filteredRoadmap,
-      patterns: filteredPatterns,
-      stack: filteredStack,
-      files: filteredFiles,
-      metrics: {
-        originalSize,
-        filteredSize,
-        reductionPercent: Math.round((1 - filteredSize / originalSize) * 100),
-        domain: taskDomain,
-      },
-    }
-  }
-
-  /**
-   * Use BM25 + import graph + co-change ranking if indexes exist,
-   * otherwise fall back to regex-based domain filtering.
-   */
-  private rankOrFilterFiles(
-    files: string[],
-    taskDescription: string,
-    projectId: string,
-    domain: ContextDomain
-  ): string[] {
-    try {
-      const indexes = hasIndexes(projectId)
-      if (indexes.bm25) {
-        const ranked = rankFiles(projectId, taskDescription, { topN: 15 })
-        if (ranked.length > 0) {
-          return ranked.map((r) => r.path)
-        }
-      }
-    } catch {
-      // Index not available — fall through to regex filter
-    }
-
-    return this.filterFiles(files, domain)
-  }
-
-  /**
-   * Filter files by domain.
-   */
-  private filterFiles(files: string[], domain: ContextDomain): string[] {
-    const patterns: Record<ContextDomain, RegExp[]> = {
-      frontend: [
-        /\.(tsx?|jsx?|vue|svelte)$/,
-        /components?\//i,
-        /pages?\//i,
-        /views?\//i,
-        /styles?\//i,
-        /hooks?\//i,
-      ],
-      backend: [
-        /\.(ts|js|py|go|rs|java)$/,
-        /api\//i,
-        /routes?\//i,
-        /controllers?\//i,
-        /services?\//i,
-        /models?\//i,
-        /handlers?\//i,
-      ],
-      devops: [
-        /\.(ya?ml|toml|dockerfile|tf)$/i,
-        /docker/i,
-        /\.github\//i,
-        /deploy/i,
-        /infra/i,
-        /k8s/i,
-      ],
-      docs: [/\.(md|mdx|rst|txt)$/i, /docs?\//i, /readme/i, /changelog/i],
-      testing: [/\.(test|spec)\./i, /tests?\//i, /__tests__\//i, /e2e\//i, /fixtures?\//i],
-      general: [],
-    }
-
-    const domainPatterns = patterns[domain]
-    if (domainPatterns.length === 0) {
-      return files // Return all for general domain
-    }
-
-    // Always include config files
-    const configPatterns = [/package\.json$/, /tsconfig\.json$/, /\.config\.(ts|js)$/]
-
-    return files.filter((file) => {
-      // Include if matches domain patterns
-      if (domainPatterns.some((p) => p.test(file))) {
-        return true
-      }
-      // Include config files
-      if (configPatterns.some((p) => p.test(file))) {
-        return true
-      }
-      return false
-    })
-  }
-
-  /**
-   * Estimate context size in approximate tokens.
-   */
-  private estimateSize(
-    context: Partial<{
-      agents: unknown[]
-      roadmap: unknown[]
-      patterns: unknown[]
-      stack: unknown
-      files: string[]
-      state: unknown
-    }>
-  ): number {
-    let size = 0
-
-    // Rough estimates: each item ~50 tokens, files ~10 tokens each
-    size += (context.agents?.length || 0) * 50
-    size += (context.roadmap?.length || 0) * 50
-    size += (context.patterns?.length || 0) * 30
-    size += context.stack ? 100 : 0
-    size += (context.files?.length || 0) * 10
-    size += context.state ? 200 : 0
-
-    return Math.max(100, size)
-  }
-
-  /**
-   * Convert TaskType to ContextDomain.
-   */
-  taskTypeToContextDomain(taskType: TaskType): ContextDomain {
-    const mapping: Record<TaskType, ContextDomain> = {
-      frontend: 'frontend',
-      backend: 'backend',
-      devops: 'devops',
-      database: 'backend',
-      testing: 'testing',
-      documentation: 'docs',
-      refactoring: 'general',
-      bugfix: 'general',
-      feature: 'general',
-      design: 'frontend',
-      other: 'general',
-    }
-    return mapping[taskType]
-  }
-
-  /**
-   * Get recommended context for a task based on history.
-   */
-  async getRecommendedContext(
-    projectId: string,
-    taskDescription: string
-  ): Promise<{
-    domain: ContextDomain
-    suggestedAgent: string | null
-    estimatedDuration: string | null
-    patterns: string[]
-  }> {
-    const domainAnalysis = this.detectDomain(taskDescription)
-    const taskType = this.contextDomainToTaskType(domainAnalysis.primary)
-
-    // Get agent suggestion
-    const agentSuggestion = await agentPerformanceTracker.suggestAgent(projectId, taskType)
-
-    // Get duration estimate
-    const durationEstimate = await outcomeAnalyzer.suggestEstimate(projectId, taskType)
-
-    // Get relevant patterns
-    const patterns = await outcomeAnalyzer.detectPatterns(projectId)
-    const relevantPatterns = patterns.slice(0, 3).map((p) => p.description)
-
-    return {
-      domain: domainAnalysis.primary,
-      suggestedAgent: agentSuggestion?.agentName || null,
-      estimatedDuration: durationEstimate,
-      patterns: relevantPatterns,
-    }
-  }
-
-  /**
-   * Convert ContextDomain to TaskType.
-   */
-  private contextDomainToTaskType(domain: ContextDomain): TaskType {
-    const mapping: Record<ContextDomain, TaskType> = {
-      frontend: 'frontend',
-      backend: 'backend',
-      devops: 'devops',
-      docs: 'documentation',
-      testing: 'testing',
-      general: 'other',
-    }
-    return mapping[domain]
-  }
-}
-
-// Singleton instance
-const smartContext = new SmartContext()
-export default smartContext
-export { SmartContext }

package/core/agentic/tech-normalizer.ts

@@ -1,167 +0,0 @@
-/**
- * Tech Normalizer (PRJ-300)
- *
- * Normalized matching for tech stack / framework names.
- * Handles:
- * - Compound names: "React + TypeScript" → ["react", "typescript"]
- * - Framework aliases: "nextjs" → "next.js"
- * - Framework families: "Next.js" → react family
- * - Case-insensitive, whitespace-insensitive matching
- */
-
-// =============================================================================
-// Framework Families
-// =============================================================================
-
-/**
- * Map framework names to their family (meta-framework → base framework).
- * Used to verify that "Next.js" matches expected "react".
- */
-const FRAMEWORK_FAMILIES: Record<string, string> = {
-  'next.js': 'react',
-  nextjs: 'react',
-  remix: 'react',
-  gatsby: 'react',
-  'react native': 'react',
-  expo: 'react',
-  nuxt: 'vue',
-  'nuxt.js': 'vue',
-  nuxtjs: 'vue',
-  sveltekit: 'svelte',
-  analog: 'angular',
-  astro: 'multi',
-  vite: 'multi',
-}
-
-/**
- * Aliases that normalize to a canonical name.
- */
-const FRAMEWORK_ALIASES: Record<string, string> = {
-  nextjs: 'next.js',
-  nuxtjs: 'nuxt.js',
-  expressjs: 'express',
-  fastifyjs: 'fastify',
-  'react.js': 'react',
-  'vue.js': 'vue',
-  'svelte.js': 'svelte',
-  'angular.js': 'angular',
-  angularjs: 'angular',
-  'node.js': 'node',
-  nodejs: 'node',
-  ts: 'typescript',
-  js: 'javascript',
-  pg: 'postgres',
-  postgresql: 'postgres',
-  mongo: 'mongodb',
-}
-
-// =============================================================================
-// Core Functions
-// =============================================================================
-
-/**
- * Normalize a single framework/tech name.
- * Strips whitespace, lowercases, resolves aliases.
- *
- * @example
- * normalizeFrameworkName("Next.js") → "next.js"
- * normalizeFrameworkName("  TypeScript ") → "typescript"
- * normalizeFrameworkName("NodeJS") → "node"
- */
-export function normalizeFrameworkName(name: string): string {
-  const trimmed = name.trim().toLowerCase()
-
-  // Check aliases
-  const aliasKey = trimmed.replace(/[.\s-]/g, '')
-  if (FRAMEWORK_ALIASES[aliasKey]) {
-    return FRAMEWORK_ALIASES[aliasKey]
-  }
-  if (FRAMEWORK_ALIASES[trimmed]) {
-    return FRAMEWORK_ALIASES[trimmed]
-  }
-
-  return trimmed
-}
-
-/**
- * Extract individual tech names from a compound string.
- * Handles separators: +, /, comma, parentheses, "with", "and".
- *
- * @example
- * extractTechNames("React + TypeScript") → ["react", "typescript"]
- * extractTechNames("Next.js (React)") → ["next.js", "react"]
- * extractTechNames("Hono with Zod") → ["hono", "zod"]
- */
-export function extractTechNames(compound: string): string[] {
-  // Replace parentheses with comma separators to split them out
-  const parts = compound
-    .replace(/[()]/g, ',')
-    .split(/[+/,]|\bwith\b|\band\b/i)
-    .map((s) => s.trim())
-    .filter((s) => s.length > 0)
-
-  return parts.map(normalizeFrameworkName)
-}
-
-/**
- * Get the framework family for a tech name.
- * Returns the base framework or the name itself if no family exists.
- *
- * @example
- * getFrameworkFamily("next.js") → "react"
- * getFrameworkFamily("nuxt") → "vue"
- * getFrameworkFamily("express") → "express"
- */
-export function getFrameworkFamily(name: string): string {
-  const normalized = normalizeFrameworkName(name)
-  return FRAMEWORK_FAMILIES[normalized] || normalized
-}
-
-/**
- * Check if two tech names match (direct or via family).
- *
- * @example
- * matchesTech("Next.js", "react") → true (Next.js is React family)
- * matchesTech("React + TypeScript", "react") → true (contains react)
- * matchesTech("Vue", "react") → false
- */
-export function matchesTech(actual: string, expected: string): boolean {
-  const expectedNorm = normalizeFrameworkName(expected)
-
-  // Extract all tech names from actual (handles compound names)
-  const actualNames = extractTechNames(actual)
-
-  for (const name of actualNames) {
-    // Direct match
-    if (name === expectedNorm) return true
-    // Family match
-    if (getFrameworkFamily(name) === expectedNorm) return true
-    // Reverse family match
-    if (getFrameworkFamily(expectedNorm) === name) return true
-  }
-
-  return false
-}
-
-/**
- * Deduplicate a tech stack list using normalized matching.
- * Preserves the first occurrence's original casing.
- *
- * @example
- * deduplicateTechStack(["React", "react", "Next.js"]) → ["React", "Next.js"]
- * deduplicateTechStack(["TypeScript", "ts"]) → ["TypeScript"]
- */
-export function deduplicateTechStack(stack: string[]): string[] {
-  const seen = new Set<string>()
-  const result: string[] = []
-
-  for (const name of stack) {
-    const normalized = normalizeFrameworkName(name)
-    if (!seen.has(normalized)) {
-      seen.add(normalized)
-      result.push(name)
-    }
-  }
-
-  return result
-}