prjct-cli 1.13.0 → 1.15.0

package/CHANGELOG.md

@@ -1,5 +1,95 @@
 # Changelog
 
+## [1.15.0] - 2026-02-09
+
+### Features
+
+- replace hardcoded memory domain tags with semantic matching (PRJ-300) (#157)
+
+
+## [1.14.1] - 2026-02-09
+
+### Improved
+- **Semantic memory domain matching** (PRJ-300): Memory retrieval now uses two-pass scoring (exact MEMORY_TAG match + semantic keyword match) instead of exact-only tag matching. Unknown domains like "uxui" are resolved to canonical domains ("frontend") via SEMANTIC_DOMAIN_KEYWORDS map.
+- **Tech stack normalizer**: New `tech-normalizer.ts` module handles framework name normalization, compound names ("React + TypeScript"), framework families (Next.js → React), and alias resolution (nextjs → next.js).
+- **Anti-hallucination dedup**: Tech stack entries in the anti-hallucination block are now deduplicated using normalized matching, preventing duplicates like "React" and "react" or "Next.js" and "nextjs".
+- **Sealed analysis priority**: Prompt builder now uses sealed analysis frameworks as primary tech stack source, falling back to repo conventions.
+
+### Implementation Details
+- Expanded `TaskDomain` type from fixed union to `KnownDomain | (string & {})` for forward compatibility while preserving autocomplete
+- `DOMAIN_TAG_MAP` now includes TECH_STACK for frontend/database domains (previously missing)
+- `SEMANTIC_DOMAIN_KEYWORDS` maps 80+ keywords across 7 domains for fuzzy domain resolution
+- `resolveCanonicalDomains()` exported for testability — resolves arbitrary strings to known domains
+- `normalizeFrameworkName()` handles 15 aliases; `FRAMEWORK_FAMILIES` maps 12 meta-frameworks to base frameworks
+- `extractTechNames()` splits compound tech strings on +, /, commas, parentheses, "with", "and"
+
+### Learnings
+- Two-pass scoring (exact 10pts + semantic 5pts) gives gradual relevance instead of binary match/no-match
+- TypeScript's `KnownDomain | (string & {})` pattern preserves autocomplete for known values while accepting any string
+- Parentheses in compound names need comma replacement (not space) — otherwise adjacent words merge into a single token
+
+### Test Plan
+
+#### For QA
+1. `bun test core/__tests__/agentic/semantic-matching.test.ts` — domain resolution (uxui→frontend, api→backend, infra→devops)
+2. `bun test core/__tests__/agentic/tech-normalizer.test.ts` — normalization, compound names, framework families, dedup
+3. `bun test core/__tests__/agentic/prompt-assembly.test.ts` — anti-hallucination block still renders correctly
+4. `bun test` — 848 tests pass, 0 fail
+
+#### For Users
+- Memory retrieval automatically surfaces related memories across domains
+- No user action needed — improvements are automatic
+- No breaking changes
+
+## [1.14.0] - 2026-02-09
+
+### Features
+
+- add sprint-based velocity calculation with trend detection (PRJ-296) (#156)
+
+
+## [1.14.0] - 2026-02-09
+
+### Features
+- **Velocity Dashboard**: New `prjct velocity` command with sprint-by-sprint breakdown, trend detection, and estimation accuracy (PRJ-296)
+- **Estimation Patterns**: Automatic detection of over/under estimation patterns by task category
+- **Completion Projections**: Given remaining backlog points, projects estimated sprints and completion date
+- **Velocity Context Injection**: Historical velocity data automatically injected into LLM task prompts for better estimation
+
+### Implementation Details
+
+**PRJ-296 — Sprint-Based Velocity Calculation**
+New velocity subsystem that aggregates completed task data (from outcomes.jsonl) into sprint periods, calculates rolling velocity metrics, detects trends, and identifies estimation patterns.
+
+Key changes:
+- `core/schemas/velocity.ts` — Zod schemas: SprintVelocity, VelocityMetrics, VelocityConfig, EstimationPattern, CompletionProjection
+- `core/domain/velocity.ts` — Velocity engine: sprint bucketing, linear regression trend detection, accuracy tracking, pattern detection, duration parsing, LLM context formatting
+- `core/storage/velocity-storage.ts` — Write-through storage extending StorageManager with markdown generation
+- `core/commands/velocity.ts` — Dashboard command with chalk-formatted output + registration
+- `core/types/agentic.ts` — Extended `OrchestratorContext` with `velocityContext` field
+- `core/agentic/orchestrator-executor.ts` — Loads velocity context in parallel via `Promise.all`
+- `core/agentic/prompt-builder.ts` — Injects velocity into Section 6 (task context)
+- `core/__tests__/domain/velocity.test.ts` — 35 new tests
+
+### Learnings
+- Derive story points from estimated duration via Fibonacci mapping when outcomes lack explicit point data
+- Linear regression slope normalized by average velocity works well for trend detection (>10% = improving, <-10% = declining)
+- Parallel loading pattern in orchestrator-executor (`Promise.all`) ensures zero-latency context enrichment
+
+### Test Plan
+
+#### For QA
+1. Run `prjct velocity` on a project with outcomes data — verify sprint-by-sprint breakdown with points, tasks, accuracy
+2. Run `prjct velocity` with no outcomes — verify graceful "No velocity data yet" message
+3. Run `prjct velocity 89` — verify completion projection (sprints remaining + date)
+4. Run `bun test core/__tests__/domain/velocity.test.ts` — 35 tests pass
+5. Run `bun test` — all 805 tests pass
+
+#### For Users
+- **What changed:** New `prjct velocity` command shows sprint velocity, estimation accuracy trends, and completion projections. Velocity data is automatically injected into task prompts for better LLM estimation.
+- **How to use:** Run `prjct velocity` after completing tasks with estimates. Add backlog points: `prjct velocity 89`
+- **Breaking changes:** None
+
 ## [1.13.0] - 2026-02-09
 
 ### Features

package/core/__tests__/agentic/semantic-matching.test.ts

@@ -0,0 +1,131 @@
+import { describe, expect, it } from 'bun:test'
+import {
+  DOMAIN_TAG_MAP,
+  resolveCanonicalDomains,
+  SEMANTIC_DOMAIN_KEYWORDS,
+} from '../../agentic/memory-system'
+import { KNOWN_DOMAINS, MEMORY_TAGS } from '../../types/memory'
+
+describe('semantic domain matching (PRJ-300)', () => {
+  describe('resolveCanonicalDomains', () => {
+    it('should pass through known domains unchanged', () => {
+      expect(resolveCanonicalDomains('frontend')).toEqual(['frontend'])
+      expect(resolveCanonicalDomains('backend')).toEqual(['backend'])
+      expect(resolveCanonicalDomains('devops')).toEqual(['devops'])
+      expect(resolveCanonicalDomains('testing')).toEqual(['testing'])
+      expect(resolveCanonicalDomains('database')).toEqual(['database'])
+      expect(resolveCanonicalDomains('general')).toEqual(['general'])
+    })
+
+    it('should resolve "uxui" to frontend', () => {
+      const result = resolveCanonicalDomains('uxui')
+      expect(result).toContain('frontend')
+    })
+
+    it('should resolve "ui" to frontend', () => {
+      const result = resolveCanonicalDomains('ui')
+      expect(result).toContain('frontend')
+    })
+
+    it('should resolve "api" to backend', () => {
+      const result = resolveCanonicalDomains('api')
+      expect(result).toContain('backend')
+    })
+
+    it('should resolve "ml-pipeline" to backend', () => {
+      const result = resolveCanonicalDomains('ml-pipeline')
+      // "pipeline" matches devops, so it should at least resolve
+      expect(result.length).toBeGreaterThan(0)
+      expect(result).not.toEqual(['general'])
+    })
+
+    it('should resolve "infra" to devops', () => {
+      const result = resolveCanonicalDomains('infra')
+      expect(result).toContain('devops')
+    })
+
+    it('should resolve "docker" to devops', () => {
+      const result = resolveCanonicalDomains('docker')
+      expect(result).toContain('devops')
+    })
+
+    it('should resolve "schema" to database', () => {
+      const result = resolveCanonicalDomains('schema')
+      expect(result).toContain('database')
+    })
+
+    it('should resolve "css" to frontend', () => {
+      const result = resolveCanonicalDomains('css')
+      expect(result).toContain('frontend')
+    })
+
+    it('should resolve "e2e" to testing', () => {
+      const result = resolveCanonicalDomains('e2e')
+      expect(result).toContain('testing')
+    })
+
+    it('should fallback to general for truly unknown domains', () => {
+      expect(resolveCanonicalDomains('quantum-computing')).toEqual(['general'])
+      expect(resolveCanonicalDomains('astrology')).toEqual(['general'])
+    })
+
+    it('should handle case-insensitive and separator-insensitive', () => {
+      expect(resolveCanonicalDomains('UI')).toContain('frontend')
+      expect(resolveCanonicalDomains('API')).toContain('backend')
+      expect(resolveCanonicalDomains('e_2_e')).toContain('testing')
+    })
+  })
+
+  describe('DOMAIN_TAG_MAP', () => {
+    it('should include TECH_STACK for frontend (improved from PRJ-107)', () => {
+      expect(DOMAIN_TAG_MAP.frontend).toContain(MEMORY_TAGS.TECH_STACK)
+    })
+
+    it('should include TECH_STACK for database', () => {
+      expect(DOMAIN_TAG_MAP.database).toContain(MEMORY_TAGS.TECH_STACK)
+    })
+
+    it('should include DEPENDENCIES for testing', () => {
+      expect(DOMAIN_TAG_MAP.testing).toContain(MEMORY_TAGS.DEPENDENCIES)
+    })
+
+    it('should include all MEMORY_TAGS for general', () => {
+      const allTags = Object.values(MEMORY_TAGS)
+      for (const tag of allTags) {
+        expect(DOMAIN_TAG_MAP.general).toContain(tag)
+      }
+    })
+
+    it('should have mappings for all known domains', () => {
+      for (const domain of KNOWN_DOMAINS) {
+        expect(DOMAIN_TAG_MAP[domain]).toBeDefined()
+        expect(DOMAIN_TAG_MAP[domain].length).toBeGreaterThan(0)
+      }
+    })
+  })
+
+  describe('SEMANTIC_DOMAIN_KEYWORDS', () => {
+    it('should map uxui-related keywords to frontend', () => {
+      expect(SEMANTIC_DOMAIN_KEYWORDS.frontend).toContain('uxui')
+      expect(SEMANTIC_DOMAIN_KEYWORDS.frontend).toContain('ui')
+      expect(SEMANTIC_DOMAIN_KEYWORDS.frontend).toContain('ux')
+      expect(SEMANTIC_DOMAIN_KEYWORDS.frontend).toContain('css')
+    })
+
+    it('should map CI/CD keywords to devops', () => {
+      expect(SEMANTIC_DOMAIN_KEYWORDS.devops).toContain('ci')
+      expect(SEMANTIC_DOMAIN_KEYWORDS.devops).toContain('cd')
+      expect(SEMANTIC_DOMAIN_KEYWORDS.devops).toContain('docker')
+      expect(SEMANTIC_DOMAIN_KEYWORDS.devops).toContain('kubernetes')
+    })
+
+    it('should have keywords for all known domains except general', () => {
+      for (const domain of KNOWN_DOMAINS) {
+        expect(SEMANTIC_DOMAIN_KEYWORDS[domain]).toBeDefined()
+        if (domain !== 'general') {
+          expect(SEMANTIC_DOMAIN_KEYWORDS[domain].length).toBeGreaterThan(0)
+        }
+      }
+    })
+  })
+})

package/core/__tests__/agentic/tech-normalizer.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, it } from 'bun:test'
+import {
+  deduplicateTechStack,
+  extractTechNames,
+  getFrameworkFamily,
+  matchesTech,
+  normalizeFrameworkName,
+} from '../../agentic/tech-normalizer'
+
+describe('tech-normalizer', () => {
+  describe('normalizeFrameworkName', () => {
+    it('should lowercase and trim', () => {
+      expect(normalizeFrameworkName('  TypeScript ')).toBe('typescript')
+      expect(normalizeFrameworkName('React')).toBe('react')
+    })
+
+    it('should resolve aliases', () => {
+      expect(normalizeFrameworkName('NodeJS')).toBe('node')
+      expect(normalizeFrameworkName('ts')).toBe('typescript')
+      expect(normalizeFrameworkName('js')).toBe('javascript')
+      expect(normalizeFrameworkName('pg')).toBe('postgres')
+      expect(normalizeFrameworkName('postgresql')).toBe('postgres')
+    })
+
+    it('should preserve dotted names', () => {
+      expect(normalizeFrameworkName('Next.js')).toBe('next.js')
+      expect(normalizeFrameworkName('Vue.js')).toBe('vue')
+    })
+
+    it('should handle nextjs alias', () => {
+      expect(normalizeFrameworkName('nextjs')).toBe('next.js')
+      expect(normalizeFrameworkName('nuxtjs')).toBe('nuxt.js')
+    })
+  })
+
+  describe('extractTechNames', () => {
+    it('should split on + separator', () => {
+      expect(extractTechNames('React + TypeScript')).toEqual(['react', 'typescript'])
+    })
+
+    it('should extract from parentheses', () => {
+      expect(extractTechNames('Next.js (React)')).toEqual(['next.js', 'react'])
+    })
+
+    it('should split on "with"', () => {
+      expect(extractTechNames('Hono with Zod')).toEqual(['hono', 'zod'])
+    })
+
+    it('should split on commas', () => {
+      expect(extractTechNames('React, Vue, Angular')).toEqual(['react', 'vue', 'angular'])
+    })
+
+    it('should handle single name', () => {
+      expect(extractTechNames('React')).toEqual(['react'])
+    })
+  })
+
+  describe('getFrameworkFamily', () => {
+    it('should resolve meta-frameworks to base', () => {
+      expect(getFrameworkFamily('next.js')).toBe('react')
+      expect(getFrameworkFamily('Next.js')).toBe('react')
+      expect(getFrameworkFamily('Remix')).toBe('react')
+      expect(getFrameworkFamily('Gatsby')).toBe('react')
+    })
+
+    it('should resolve Vue meta-frameworks', () => {
+      expect(getFrameworkFamily('nuxt')).toBe('vue')
+      expect(getFrameworkFamily('Nuxt.js')).toBe('vue')
+    })
+
+    it('should resolve Svelte meta-framework', () => {
+      expect(getFrameworkFamily('SvelteKit')).toBe('svelte')
+    })
+
+    it('should return name itself for base frameworks', () => {
+      expect(getFrameworkFamily('React')).toBe('react')
+      expect(getFrameworkFamily('Express')).toBe('express')
+      expect(getFrameworkFamily('Hono')).toBe('hono')
+    })
+  })
+
+  describe('matchesTech', () => {
+    it('should match exact names (case-insensitive)', () => {
+      expect(matchesTech('React', 'react')).toBe(true)
+      expect(matchesTech('react', 'React')).toBe(true)
+    })
+
+    it('should match via framework family', () => {
+      expect(matchesTech('Next.js', 'react')).toBe(true)
+      expect(matchesTech('Nuxt', 'vue')).toBe(true)
+      expect(matchesTech('SvelteKit', 'svelte')).toBe(true)
+    })
+
+    it('should match compound names', () => {
+      expect(matchesTech('React + TypeScript', 'react')).toBe(true)
+      expect(matchesTech('React + TypeScript', 'typescript')).toBe(true)
+    })
+
+    it('should match parenthesized names', () => {
+      expect(matchesTech('Next.js (React)', 'react')).toBe(true)
+      expect(matchesTech('Next.js (React)', 'next.js')).toBe(true)
+    })
+
+    it('should not match unrelated frameworks', () => {
+      expect(matchesTech('Vue', 'react')).toBe(false)
+      expect(matchesTech('Angular', 'react')).toBe(false)
+    })
+  })
+
+  describe('deduplicateTechStack', () => {
+    it('should remove case-insensitive duplicates', () => {
+      expect(deduplicateTechStack(['React', 'react', 'REACT'])).toEqual(['React'])
+    })
+
+    it('should remove alias duplicates', () => {
+      expect(deduplicateTechStack(['TypeScript', 'ts'])).toEqual(['TypeScript'])
+      expect(deduplicateTechStack(['Node.js', 'nodejs'])).toEqual(['Node.js'])
+    })
+
+    it('should preserve unique entries', () => {
+      expect(deduplicateTechStack(['React', 'Next.js', 'TypeScript'])).toEqual([
+        'React',
+        'Next.js',
+        'TypeScript',
+      ])
+    })
+
+    it('should preserve first occurrence casing', () => {
+      expect(deduplicateTechStack(['Next.js', 'nextjs', 'NEXT.JS'])).toEqual(['Next.js'])
+    })
+
+    it('should handle empty array', () => {
+      expect(deduplicateTechStack([])).toEqual([])
+    })
+  })
+})