prjct-cli 1.14.0 → 1.16.0

package/CHANGELOG.md

@@ -1,5 +1,83 @@
 # Changelog
 
+## [1.16.0] - 2026-02-09
+
+### Features
+
+- remove JSON storage redundancy, SQLite-only backend (PRJ-303) (#158)
+
+
+## [1.16.0] - 2026-02-08
+
+### Features
+- **Remove JSON storage redundancy** (PRJ-303): SQLite is now the sole storage backend. JSON dual-write removed from StorageManager and IndexStorage. Auto-migration runs during `prjct sync`, deletes source JSON files after backup.
+
+### Implementation Details
+- `StorageManager.write()` — removed JSON file write and temp file pattern; writes only to SQLite kv_store + regenerates context MD
+- `StorageManager.read()` — removed JSON fallback; reads from cache → SQLite → default
+- `StorageManager.exists()` — removed JSON file check; checks SQLite only
+- `IndexStorage` — all 5 read methods (readIndex, readChecksums, readScores, readDomains, readCategories) no longer fall back to JSON; all 5 write methods no longer create JSON files
+- `migrateJsonToSqlite()` — new cleanup step deletes `storage/*.json`, `index/*.json`, `memory/*.jsonl` after successful migration; keeps `storage/backup/`
+- `SyncService.sync()` — auto-runs `migrateJsonToSqlite()` after directory setup (idempotent)
+- `PrjctDatabase.getDb()` — ensures parent directory exists before creating SQLite DB
+- `database.ts` — fixed all TS errors: `db.exec()` → `db.run()` (deprecated), `unknown[]` → `SQLQueryBindings[]`, `require()` → `fs.existsSync()`
+
+### Test Plan
+
+#### For QA
+1. Run `bun test` — all 879 tests must pass
+2. Run `prjct sync` on existing project — verify migration runs, JSON files deleted, `prjct.db` has data
+3. Run `prjct sync` again — verify idempotent (no errors, migration skips)
+4. Verify `storage/backup/` contains pre-migration JSON files
+5. Verify `context/*.md` files still generated after writes
+6. Run `prjct status` — verify state reads from SQLite
+
+#### For Users
+**What changed:** Storage is now fully SQLite-backed. JSON files are auto-migrated and removed during sync.
+**How to use:** Run `prjct sync` — migration happens automatically.
+**Breaking changes:** None — all public APIs unchanged. JSON backups preserved in `storage/backup/`.
+
+## [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

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([])
+    })
+  })
+})