prjct-cli 0.63.0 → 0.64.0

package/CHANGELOG.md

@@ -1,5 +1,66 @@
 # Changelog
 
+## [0.64.0] - 2026-02-05
+
+### Features
+
+- add input source tagging for context items (PRJ-102) (#106)
+
+
+## [0.63.2] - 2026-02-05
+
+### Added
+
+- **Input source tagging (PRJ-102)**: Context items now support origin tracking via `_source` metadata
+
+### Implementation Details
+
+Added `InputSource` type with 10 standardized source categories (user_explicit, user_file, system_detected, system_generated, system_inferred, learned, external, inherited, cached, unknown). Created `SourceMetadata` interface with capturedAt timestamp and optional confidence/sourcePath fields. Added `SourcedItem` base interface and `createSourceMetadata()` helper function. Extended key context interfaces (AgentInfo, FeatureInfo, PatternInfo, GatheredInfo, LoadedAgent) to support source tracking. Updated MemoryMetadata with inputSource field for consistency.
+
+### Learnings
+
+- Anthropic pattern: always track origin of all data for traceability and debugging
+- Using optional `_source` field allows backward-compatible adoption
+
+### Test Plan
+
+#### For QA
+1. Run `bun run typecheck` - passes with new types
+2. Run `bun test` - all 368 tests pass
+3. Verify `InputSource` type is exported from `core/types`
+
+#### For Users
+- Context items now support source tracking via `_source` metadata
+- Use `createSourceMetadata()` when creating context items
+- No breaking changes
+
+
+## [0.63.1] - 2026-02-05
+
+### Added
+
+- **Unit tests for smart-context.ts (PRJ-84)**: 57 tests covering domain detection, file filtering, and type mappings
+
+### Implementation Details
+
+Created comprehensive test suite for SmartContext class: `detectDomain()` tests for all 6 domains (frontend, backend, devops, docs, testing, general), `filterFiles()` tests for file pattern matching, `estimateSize()` tests for token estimation, and type mapping function tests.
+
+### Learnings
+
+- Keyword detection uses substring matching - "be" in "better" matches backend keyword
+- Frontend file pattern `/\.(tsx?|jsx?)$/` also matches plain `.ts` files (known behavior)
+- Confidence scoring caps at 0.95 regardless of keyword count
+
+### Test Plan
+
+#### For QA
+1. Run `bun test core/__tests__/agentic/smart-context.test.ts` - all 57 tests pass
+2. Run `bun test` - full suite passes (368 tests)
+
+#### For Users
+- No user-facing changes (test coverage improvement)
+
+
 ## [0.63.0] - 2026-02-05
 
 ### Features

package/core/__tests__/agentic/smart-context.test.ts

@@ -0,0 +1,372 @@
+/**
+ * Smart Context Tests
+ * PRJ-84: Unit tests for smart-context.ts
+ */
+
+import { describe, expect, it } from 'bun:test'
+import smartContext, { SmartContext } from '../../agentic/smart-context'
+import type { ContextDomain, TaskType } from '../../types'
+
+describe('SmartContext PRJ-84', () => {
+  describe('detectDomain', () => {
+    describe('frontend detection', () => {
+      it('should detect frontend from UI keywords', () => {
+        const result = smartContext.detectDomain('Add a new button component')
+        expect(result.primary).toBe('frontend')
+        expect(result.confidence).toBeGreaterThan(0.5)
+      })
+
+      it('should detect frontend from React keywords', () => {
+        const result = smartContext.detectDomain('Create React component for user profile')
+        expect(result.primary).toBe('frontend')
+      })
+
+      it('should detect frontend from styling keywords', () => {
+        const result = smartContext.detectDomain('Fix CSS layout for responsive design')
+        expect(result.primary).toBe('frontend')
+      })
+
+      it('should detect frontend from TSX/JSX keywords', () => {
+        const result = smartContext.detectDomain('Update tsx file for modal animation')
+        expect(result.primary).toBe('frontend')
+      })
+    })
+
+    describe('backend detection', () => {
+      it('should detect backend from API keywords', () => {
+        const result = smartContext.detectDomain('Create new API endpoint for users')
+        expect(result.primary).toBe('backend')
+        expect(result.confidence).toBeGreaterThan(0.5)
+      })
+
+      it('should detect backend from database keywords', () => {
+        const result = smartContext.detectDomain('Add database query for orders')
+        expect(result.primary).toBe('backend')
+      })
+
+      it('should detect backend from service keywords', () => {
+        const result = smartContext.detectDomain('Implement auth service handler')
+        expect(result.primary).toBe('backend')
+      })
+
+      it('should detect backend from GraphQL keywords', () => {
+        const result = smartContext.detectDomain('Add GraphQL resolver for products')
+        expect(result.primary).toBe('backend')
+      })
+    })
+
+    describe('devops detection', () => {
+      it('should detect devops from Docker keywords', () => {
+        const result = smartContext.detectDomain('Create Docker container for deployment')
+        expect(result.primary).toBe('devops')
+        expect(result.confidence).toBeGreaterThan(0.5)
+      })
+
+      it('should detect devops from Kubernetes keywords', () => {
+        const result = smartContext.detectDomain('Update k8s deployment configuration')
+        expect(result.primary).toBe('devops')
+      })
+
+      it('should detect devops from CI/CD keywords', () => {
+        const result = smartContext.detectDomain('Fix CI pipeline for build process')
+        expect(result.primary).toBe('devops')
+      })
+
+      it('should detect devops from infrastructure keywords', () => {
+        const result = smartContext.detectDomain('Configure AWS infrastructure with terraform')
+        expect(result.primary).toBe('devops')
+      })
+    })
+
+    describe('docs detection', () => {
+      it('should detect docs from documentation keywords', () => {
+        // Note: "documentation" alone triggers docs domain
+        const result = smartContext.detectDomain('Update documentation for users')
+        expect(result.primary).toBe('docs')
+        expect(result.confidence).toBeGreaterThan(0.5)
+      })
+
+      it('should detect docs from README keywords', () => {
+        const result = smartContext.detectDomain('Add readme section for installation')
+        expect(result.primary).toBe('docs')
+      })
+
+      it('should detect docs from changelog keywords', () => {
+        const result = smartContext.detectDomain('Update changelog for new release')
+        expect(result.primary).toBe('docs')
+      })
+
+      it('should detect docs from jsdoc keywords', () => {
+        const result = smartContext.detectDomain('Add jsdoc comments to functions')
+        expect(result.primary).toBe('docs')
+      })
+    })
+
+    describe('testing detection', () => {
+      it('should detect testing from test keywords', () => {
+        const result = smartContext.detectDomain('Add unit test for user service')
+        expect(result.primary).toBe('testing')
+        expect(result.confidence).toBeGreaterThan(0.5)
+      })
+
+      it('should detect testing from Jest keywords', () => {
+        const result = smartContext.detectDomain('Write jest spec for validation')
+        expect(result.primary).toBe('testing')
+      })
+
+      it('should detect testing from e2e keywords', () => {
+        const result = smartContext.detectDomain('Add e2e integration tests')
+        expect(result.primary).toBe('testing')
+      })
+
+      it('should detect testing from coverage keywords', () => {
+        const result = smartContext.detectDomain('Improve test coverage for auth module')
+        expect(result.primary).toBe('testing')
+      })
+
+      it('should detect testing from mock/fixture keywords', () => {
+        const result = smartContext.detectDomain('Create mock fixtures for API tests')
+        expect(result.primary).toBe('testing')
+      })
+    })
+
+    describe('general/fallback detection', () => {
+      it('should return general for ambiguous tasks', () => {
+        const result = smartContext.detectDomain('Refactor code')
+        expect(result.primary).toBe('general')
+        expect(result.confidence).toBe(0.5)
+      })
+
+      it('should return general for empty descriptions', () => {
+        const result = smartContext.detectDomain('')
+        expect(result.primary).toBe('general')
+      })
+
+      it('should return general for non-technical descriptions', () => {
+        // Note: "be" in "better" matches backend keyword, so use different text
+        const result = smartContext.detectDomain('Improve this somehow')
+        expect(result.primary).toBe('general')
+      })
+    })
+
+    describe('secondary domains', () => {
+      it('should detect secondary domains for mixed tasks', () => {
+        const result = smartContext.detectDomain('Add API endpoint with React frontend component')
+        expect(result.primary).toBeDefined()
+        expect(result.secondary.length).toBeGreaterThan(0)
+      })
+
+      it('should limit secondary domains to max 2', () => {
+        const result = smartContext.detectDomain(
+          'Add API endpoint with React component and Docker deploy with test coverage'
+        )
+        expect(result.secondary.length).toBeLessThanOrEqual(2)
+      })
+    })
+
+    describe('confidence scoring', () => {
+      it('should have higher confidence for strong domain signals', () => {
+        const strong = smartContext.detectDomain('Create React component with jsx tsx ui')
+        const weak = smartContext.detectDomain('Fix bug in component')
+        // Strong has multiple matching keywords, weak has fewer
+        expect(strong.confidence).toBeGreaterThanOrEqual(weak.confidence)
+      })
+
+      it('should cap confidence at 0.95', () => {
+        const result = smartContext.detectDomain(
+          'ui component react vue angular css style button form modal layout responsive animation dom html frontend jsx tsx'
+        )
+        expect(result.confidence).toBeLessThanOrEqual(0.95)
+      })
+    })
+  })
+
+  describe('filterFiles', () => {
+    const testFiles = [
+      'src/components/Button.tsx',
+      'src/components/Modal.jsx',
+      'src/api/users.ts',
+      'src/services/auth.ts',
+      'src/models/User.ts',
+      'docker/Dockerfile',
+      '.github/workflows/ci.yml',
+      'deploy/k8s/deployment.yaml',
+      'docs/README.md',
+      'docs/api.md',
+      'tests/unit/auth.test.ts',
+      '__tests__/components/Button.test.tsx',
+      'package.json',
+      'tsconfig.json',
+      'vite.config.ts',
+    ]
+
+    // Access private method via class instance
+    const smartContextInstance = new SmartContext()
+    const filterFiles = (files: string[], domain: ContextDomain) => {
+      // @ts-expect-error - accessing private method for testing
+      return smartContextInstance.filterFiles(files, domain)
+    }
+
+    describe('frontend filtering', () => {
+      it('should include component files', () => {
+        const result = filterFiles(testFiles, 'frontend')
+        expect(result).toContain('src/components/Button.tsx')
+        expect(result).toContain('src/components/Modal.jsx')
+      })
+
+      it('should include config files', () => {
+        const result = filterFiles(testFiles, 'frontend')
+        expect(result).toContain('package.json')
+        expect(result).toContain('tsconfig.json')
+      })
+
+      it('should exclude non-code files', () => {
+        const result = filterFiles(testFiles, 'frontend')
+        // Note: .ts files match frontend pattern /\.(tsx?|jsx?)$/ because tsx? = ts or tsx
+        // So backend .ts files are included - this is a known quirk
+        expect(result).not.toContain('docker/Dockerfile')
+        expect(result).not.toContain('docs/README.md')
+      })
+    })
+
+    describe('backend filtering', () => {
+      it('should include API and service files', () => {
+        const result = filterFiles(testFiles, 'backend')
+        expect(result).toContain('src/api/users.ts')
+        expect(result).toContain('src/services/auth.ts')
+        expect(result).toContain('src/models/User.ts')
+      })
+
+      it('should include config files', () => {
+        const result = filterFiles(testFiles, 'backend')
+        expect(result).toContain('package.json')
+      })
+    })
+
+    describe('devops filtering', () => {
+      it('should include Docker and CI files', () => {
+        const result = filterFiles(testFiles, 'devops')
+        expect(result).toContain('docker/Dockerfile')
+        expect(result).toContain('.github/workflows/ci.yml')
+        expect(result).toContain('deploy/k8s/deployment.yaml')
+      })
+    })
+
+    describe('docs filtering', () => {
+      it('should include markdown files', () => {
+        const result = filterFiles(testFiles, 'docs')
+        expect(result).toContain('docs/README.md')
+        expect(result).toContain('docs/api.md')
+      })
+    })
+
+    describe('testing filtering', () => {
+      it('should include test files', () => {
+        const result = filterFiles(testFiles, 'testing')
+        expect(result).toContain('tests/unit/auth.test.ts')
+        expect(result).toContain('__tests__/components/Button.test.tsx')
+      })
+    })
+
+    describe('general filtering', () => {
+      it('should return all files for general domain', () => {
+        const result = filterFiles(testFiles, 'general')
+        expect(result).toEqual(testFiles)
+      })
+    })
+  })
+
+  describe('estimateSize', () => {
+    // @ts-expect-error - accessing private method for testing
+    const estimateSize = smartContext.estimateSize.bind(smartContext)
+
+    it('should return minimum 100 for empty context', () => {
+      const result = estimateSize({})
+      expect(result).toBe(100)
+    })
+
+    it('should estimate agents at ~50 tokens each', () => {
+      const result = estimateSize({ agents: [{}, {}, {}] })
+      expect(result).toBe(150) // 3 * 50
+    })
+
+    it('should estimate roadmap items at ~50 tokens each', () => {
+      const result = estimateSize({ roadmap: [{}, {}] })
+      expect(result).toBe(100) // 2 * 50
+    })
+
+    it('should estimate patterns at ~30 tokens each', () => {
+      const result = estimateSize({ patterns: [{}, {}, {}, {}] })
+      expect(result).toBe(120) // 4 * 30
+    })
+
+    it('should estimate stack at 100 tokens', () => {
+      const result = estimateSize({ stack: {} })
+      expect(result).toBe(100)
+    })
+
+    it('should estimate files at ~10 tokens each', () => {
+      const result = estimateSize({ files: ['a', 'b', 'c', 'd', 'e'] })
+      expect(result).toBe(100) // 5 * 10 = 50, min 100
+    })
+
+    it('should estimate state at 200 tokens', () => {
+      const result = estimateSize({ state: {} })
+      expect(result).toBe(200)
+    })
+
+    it('should combine all estimates', () => {
+      const result = estimateSize({
+        agents: [{}, {}], // 100
+        roadmap: [{}], // 50
+        patterns: [{}], // 30
+        stack: {}, // 100
+        files: ['a'], // 10
+        state: {}, // 200
+      })
+      expect(result).toBe(490)
+    })
+  })
+
+  describe('taskTypeToContextDomain', () => {
+    const testCases: Array<{ input: TaskType; expected: ContextDomain }> = [
+      { input: 'frontend', expected: 'frontend' },
+      { input: 'backend', expected: 'backend' },
+      { input: 'devops', expected: 'devops' },
+      { input: 'database', expected: 'backend' },
+      { input: 'testing', expected: 'testing' },
+      { input: 'documentation', expected: 'docs' },
+      { input: 'refactoring', expected: 'general' },
+      { input: 'bugfix', expected: 'general' },
+      { input: 'feature', expected: 'general' },
+      { input: 'design', expected: 'frontend' },
+      { input: 'other', expected: 'general' },
+    ]
+
+    for (const { input, expected } of testCases) {
+      it(`should map ${input} to ${expected}`, () => {
+        expect(smartContext.taskTypeToContextDomain(input)).toBe(expected)
+      })
+    }
+  })
+
+  describe('contextDomainToTaskType (via getRecommendedContext)', () => {
+    // Test the private method indirectly through detectDomain verification
+    it('should have consistent bidirectional mapping for core domains', () => {
+      // Frontend maps to frontend
+      const frontendResult = smartContext.detectDomain('Create React component')
+      expect(frontendResult.primary).toBe('frontend')
+      expect(smartContext.taskTypeToContextDomain('frontend')).toBe('frontend')
+
+      // Backend maps to backend
+      const backendResult = smartContext.detectDomain('Add API endpoint')
+      expect(backendResult.primary).toBe('backend')
+      expect(smartContext.taskTypeToContextDomain('backend')).toBe('backend')
+
+      // Testing maps to testing
+      const testingResult = smartContext.detectDomain('Add unit test')
+      expect(testingResult.primary).toBe('testing')
+      expect(smartContext.taskTypeToContextDomain('testing')).toBe('testing')
+    })
+  })
+})

package/core/types/agentic.ts

@@ -5,6 +5,66 @@
 
 import type { CommandParams, ContextPaths } from './core'
 
+// =============================================================================
+// Input Source Types (PRJ-102)
+// =============================================================================
+
+/**
+ * Source of context data - tracks origin for traceability.
+ * Pattern from Anthropic: always track where data comes from.
+ *
+ * @see PRJ-102
+ */
+export type InputSource =
+  | 'user_explicit' // User directly provided this (e.g., task description, idea)
+  | 'user_file' // From a user-created file (e.g., PRJCT.md, custom agents)
+  | 'system_detected' // Automatically detected (e.g., stack detection, git analysis)
+  | 'system_generated' // Generated by the system (e.g., now.md, analysis)
+  | 'system_inferred' // Inferred from other data (e.g., domain detection)
+  | 'learned' // Learned from patterns/history
+  | 'external' // From external service (e.g., Linear, JIRA)
+  | 'inherited' // Inherited from parent context (monorepo)
+  | 'cached' // From cache (may be stale)
+  | 'unknown' // Source not tracked (legacy data)
+
+/**
+ * Metadata about data source and freshness.
+ */
+export interface SourceMetadata {
+  /** Where this data came from */
+  source: InputSource
+  /** When this was captured/detected */
+  capturedAt: string
+  /** Confidence in this data (0-1) */
+  confidence?: number
+  /** Path to source file if applicable */
+  sourcePath?: string
+  /** Whether this might be stale */
+  mayBeStale?: boolean
+}
+
+/**
+ * Base interface for any item with source tracking.
+ */
+export interface SourcedItem {
+  /** Metadata about where this item came from */
+  _source?: SourceMetadata
+}
+
+/**
+ * Create source metadata with current timestamp.
+ */
+export function createSourceMetadata(
+  source: InputSource,
+  options: Partial<Omit<SourceMetadata, 'source'>> = {}
+): SourceMetadata {
+  return {
+    source,
+    capturedAt: new Date().toISOString(),
+    ...options,
+  }
+}
+
 // =============================================================================
 // Tool Registry Types
 // =============================================================================
@@ -73,21 +133,21 @@ export interface FilteredContext {
   metrics: FilterMetrics
 }
 
-export interface AgentInfo {
+export interface AgentInfo extends SourcedItem {
   name: string
   domain: ContextDomain
   skills: string[]
   successRate?: number
 }
 
-export interface FeatureInfo {
+export interface FeatureInfo extends SourcedItem {
   id: string
   name: string
   relatedTo: ContextDomain[]
   status: string
 }
 
-export interface PatternInfo {
+export interface PatternInfo extends SourcedItem {
   description: string
   domain: ContextDomain
   confidence: number
@@ -211,11 +271,14 @@ export interface PlanParams extends CommandParams {
   verbose?: boolean
 }
 
-export interface GatheredInfo {
+export interface GatheredInfo extends SourcedItem {
   type: GatheredInfoType
+  /** Path or identifier of the source */
   source: string
   data: string | GatheredFileData | GatheredAnalysisData
   gatheredAt: string
+  /** Input source category for traceability */
+  inputSource?: InputSource
 }
 
 export type GatheredInfoType =
@@ -580,7 +643,7 @@ export interface LearnedPatterns {
 /**
  * A loaded agent with its content
  */
-export interface LoadedAgent {
+export interface LoadedAgent extends SourcedItem {
   name: string
   domain: string
   content: string

package/core/types/index.ts

@@ -50,6 +50,8 @@ export type {
   GroundTruthContext,
   HallucinationPattern,
   HallucinationResult,
+  // Input Source types (PRJ-102)
+  InputSource,
   LearnedPatterns,
   LearnedPatternsRecord,
   LoadedAgent,
@@ -81,6 +83,9 @@ export type {
   SimpleExecutionResult,
   SkillContext,
   SmartContextProjectState,
+  // Source tracking types (PRJ-102)
+  SourcedItem,
+  SourceMetadata,
   StackInfo,
   Template,
   ThinkBlock,
@@ -92,6 +97,7 @@ export type {
   VerificationResult,
   Verifier,
 } from './agentic'
+export { createSourceMetadata } from './agentic'
 // =============================================================================
 // Agent Types
 // =============================================================================
@@ -248,6 +254,7 @@ export type {
   Decision,
   HistoryEntry,
   HistoryEventType,
+  LegacyMemorySource,
   Memory,
   MemoryContext,
   MemoryContextParams,

package/core/types/memory.ts

@@ -3,6 +3,8 @@
  * Types for the memory system that tracks user preferences and patterns.
  */
 
+import type { InputSource } from './agentic'
+
 /**
  * Semantic tags for memory categorization.
  * Use these constants instead of raw strings.
@@ -49,6 +51,12 @@ export interface Memory {
   observationCount?: number
 }
 
+/**
+ * Legacy source type - use InputSource for new code.
+ * @deprecated Use InputSource from agentic.ts instead
+ */
+export type LegacyMemorySource = 'user' | 'system' | 'learned'
+
 /**
  * Metadata associated with a memory entry.
  */
@@ -61,8 +69,10 @@ export interface MemoryMetadata {
   taskId?: string
   /** Related feature name */
   feature?: string
-  /** Source of the memory */
-  source?: 'user' | 'system' | 'learned'
+  /** Source of the memory (legacy - use inputSource for new code) */
+  source?: LegacyMemorySource
+  /** Input source category for traceability (PRJ-102) */
+  inputSource?: InputSource
 }
 
 /**

package/dist/bin/prjct.mjs

@@ -12419,6 +12419,13 @@ var init_plan_mode = __esm({
   }
 });
 
+// core/types/agentic.ts
+var init_agentic = __esm({
+  "core/types/agentic.ts"() {
+    "use strict";
+  }
+});
+
 // core/types/bus.ts
 var init_bus = __esm({
   "core/types/bus.ts"() {
@@ -12445,6 +12452,7 @@ var init_integrations = __esm({
 var init_types3 = __esm({
   "core/types/index.ts"() {
     "use strict";
+    init_agentic();
     init_bus();
     init_fs();
     init_integrations();
@@ -26837,7 +26845,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "0.63.0",
+      version: "0.64.0",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.63.0",
+  "version": "0.64.0",
   "description": "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
   "main": "core/index.ts",
   "bin": {