prjct-cli 0.7.1 → 0.7.3

package/CHANGELOG.md

@@ -7,6 +7,117 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.7.3] - 2025-10-05
+
+### Added
+
+- **Comprehensive Testing Documentation** - Complete testing guide and setup documentation
+  - **TESTING.md** - Full testing guide with:
+    - Quick start commands for running tests
+    - Vitest workspace architecture (core + website)
+    - Detailed configuration for both Node.js and React environments
+    - Testing best practices and examples
+    - CI/CD integration documentation
+    - Troubleshooting guide
+    - Complete command reference
+  - **README.md Testing Section** - Quick reference with:
+    - Quick start commands
+    - Test suites overview (Core CLI + Website)
+    - CI/CD automation status
+    - Link to comprehensive TESTING.md guide
+  - **Documentation Quality**: Professional-grade testing documentation for contributors and developers
+  - **Coverage**: Documents all 283 tests across both core and website projects
+
+### Fixed
+
+- **Lint Errors** - Removed 3 unused variables to pass ESLint
+  - Removed unused `globalProjectPath` in commands.js
+  - Removed unused `architectSession` require in commands.js
+  - Removed unused `fs` import in session-manager.js
+
+### Technical Details
+
+- **Testing Stack**: Vitest with workspace configuration for dual environments
+- **Core Tests** (Node.js): 179 tests for agentic system, commands, and utilities
+- **Website Tests** (React): 104 tests with Testing Library for components
+- **CI/CD**: GitHub Actions workflow with parallel test execution
+- **Coverage**: V8 coverage provider with HTML reports
+
+## [0.7.2] - 2025-10-04
+
+### Fixed
+
+- **Vercel Deployment Configuration** - Fixed deployment build and configuration
+  - Updated vercel build commands to use npm prefix syntax
+  - Moved and simplified vercel.json config
+  - Added Vercel deployment config and removed CNAME file
+  - Fixed build output directory configuration
+
+### Changed
+
+- **Version Bump** - Updated from 0.7.1 to 0.7.2
+
+## [0.7.1] - 2025-10-04
+
+### Added
+
+- **Command Implementation Status** - Added setup and migrate-all commands
+  - Marked roadmap, status, and build commands as implemented in registry
+  - Added isSupported flag to agent detection for Claude and Terminal agents
+  - Better clarity on which commands are available in each environment
+
+## [0.7.0] - 2025-10-04
+
+### Added
+
+- **Vercel Analytics Integration** - Added Vercel Analytics and Speed Insights tracking
+  - Real-time performance monitoring for website
+  - User analytics and insights
+  - Speed metrics tracking
+
+- **AI Policy Page** - New dedicated page for AI usage policies
+  - Redesigned footer layout with AI Policy link
+  - Clear transparency about AI integration
+  - Updated navigation structure
+
+### Changed
+
+- **Repository Privacy** - Transitioned from open source to proprietary
+  - Removed all GitHub repository links from website
+  - Removed open source references
+  - Updated Terms of Use with proprietary license
+  - Repository made private due to AI agent privacy concerns and terms of use compliance
+  - FREE tier remains available to all users indefinitely
+  - Contact: jlopezlira@gmail.com or jlopezlira.dev
+
+- **Deployment Migration** - Migrated from GitHub Pages to Vercel
+  - Better build performance and CDN
+  - Automatic deployments
+  - Improved website hosting
+
+- **Workflow Simplification** - Reduced to 5 essential commands
+  - Streamlined developer experience
+  - Clearer command structure
+  - Focus on core functionality
+
+- **Documentation Updates**
+  - Added session-based architecture documentation with auto-archiving
+  - JSONL logs for better performance
+  - Moved Changelog link from header to footer
+
+### Fixed
+
+- **TypeScript Build Errors** - Resolved all TypeScript errors in website build
+  - Removed unused Globe import from Privacy.tsx
+  - Fixed type errors across components
+
+### Technical Details
+
+- **Session Architecture**: JSONL-based logging with auto-archiving after 30 days
+- **Deployment**: Vercel platform with automatic builds
+- **Analytics**: Vercel Analytics + Speed Insights integration
+- **Privacy**: Repository now private, free tier remains available
+
 ## [0.6.0] - 2025-10-03
 
 ### Changed

package/README.md

@@ -14,6 +14,8 @@ Developer momentum tool for indie hackers and small teams.
 
 [![Claude Code Ready](https://img.shields.io/badge/Claude%20Code-Ready-6366f1)](CLAUDE.md)
 [![Claude Desktop Compatible](https://img.shields.io/badge/Claude%20Desktop-Compatible-6366f1)]()
+[![Tests](https://github.com/jlopezlira/prjct-cli/actions/workflows/test.yml/badge.svg)](https://github.com/jlopezlira/prjct-cli/actions/workflows/test.yml)
+[![Website Build](https://img.shields.io/badge/website-deployed-success)](https://prjct.app)
 
 ## 🤖 Claude-Native Architecture
 
@@ -361,6 +363,36 @@ prjct recap                # Show progress
 
 > 📚 **More workflows:** Visit [prjct.app/workflows-guide](https://prjct.app/workflows-guide) for detailed interactive examples
 
+## 🧪 Testing
+
+prjct-cli uses **Vitest** with comprehensive test coverage for both the CLI core and website.
+
+### Quick Start
+
+```bash
+# Run all tests
+npm test
+
+# Run tests in watch mode
+npm run test:watch
+
+# Generate coverage report
+npm run test:coverage
+```
+
+### Test Suites
+
+- **Core CLI** (Node.js) - Agentic system, commands, and utilities
+- **Website** (React + TypeScript) - Component tests with Testing Library
+
+### CI/CD
+
+Tests run automatically on every push and pull request via GitHub Actions.
+
+[![Tests](https://github.com/jlopezlira/prjct-cli/actions/workflows/test.yml/badge.svg)](https://github.com/jlopezlira/prjct-cli/actions/workflows/test.yml)
+
+> 📖 **Full testing guide:** See [TESTING.md](TESTING.md) for detailed documentation, configuration, and best practices.
+
 ## ❓ FAQ
 
 **Can I work on multiple tasks?**

package/core/__tests__/agentic/command-executor.test.js

@@ -0,0 +1,223 @@
+import { describe, it, expect } from 'vitest'
+import commandExecutor from '../../agentic/command-executor.js'
+
+describe('Command Executor', () => {
+  const testProjectPath = process.cwd()
+
+  describe('execute()', () => {
+    it('should execute command successfully', async () => {
+      const result = await commandExecutor.execute('now', {}, testProjectPath)
+
+      expect(result).toBeDefined()
+      expect(result.success).toBe(true)
+    })
+
+    it('should load template', async () => {
+      const result = await commandExecutor.execute('now', {}, testProjectPath)
+
+      expect(result.template).toBeDefined()
+      expect(result.template).toHaveProperty('content')
+      expect(result.template).toHaveProperty('frontmatter')
+    })
+
+    it('should build context', async () => {
+      const result = await commandExecutor.execute('now', {}, testProjectPath)
+
+      expect(result.context).toBeDefined()
+      expect(result.context).toHaveProperty('projectId')
+      expect(result.context).toHaveProperty('projectPath')
+      expect(result.context).toHaveProperty('paths')
+    })
+
+    it('should load state', async () => {
+      const result = await commandExecutor.execute('now', {}, testProjectPath)
+
+      expect(result.state).toBeDefined()
+      expect(typeof result.state).toBe('object')
+    })
+
+    it('should build prompt', async () => {
+      const result = await commandExecutor.execute('now', {}, testProjectPath)
+
+      expect(result.prompt).toBeDefined()
+      expect(typeof result.prompt).toBe('string')
+      expect(result.prompt.length).toBeGreaterThan(0)
+    })
+
+    it('should pass parameters to context', async () => {
+      const params = { taskName: 'Test Task', feature: 'Test Feature' }
+      const result = await commandExecutor.execute('now', params, testProjectPath)
+
+      expect(result.context.params).toEqual(params)
+    })
+
+    it('should handle different commands', async () => {
+      const commands = ['now', 'done', 'next', 'ship']
+
+      for (const cmd of commands) {
+        const result = await commandExecutor.execute(cmd, {}, testProjectPath)
+        expect(result.success).toBe(true)
+      }
+    })
+
+    it('should handle non-existent command', async () => {
+      const result = await commandExecutor.execute('nonexistent', {}, testProjectPath)
+
+      expect(result.success).toBe(false)
+      expect(result.error).toBeDefined()
+      expect(result.error).toContain('Template not found')
+    })
+
+    it('should include all execution data', async () => {
+      const result = await commandExecutor.execute('now', {}, testProjectPath)
+
+      expect(result).toHaveProperty('success')
+      expect(result).toHaveProperty('template')
+      expect(result).toHaveProperty('context')
+      expect(result).toHaveProperty('state')
+      expect(result).toHaveProperty('prompt')
+    })
+  })
+
+  describe('executeTool()', () => {
+    it('should execute allowed tool', async () => {
+      const allowedTools = ['Read', 'Write', 'Bash']
+      const result = await commandExecutor.executeTool('Read', [__filename], allowedTools)
+
+      expect(result).toBeDefined()
+    })
+
+    it('should throw error for disallowed tool', async () => {
+      const allowedTools = ['Read']
+
+      await expect(commandExecutor.executeTool('Write', ['file.txt', 'content'], allowedTools)).rejects.toThrow(
+        'Tool Write not allowed for this command'
+      )
+    })
+
+    it('should execute Read tool', async () => {
+      const allowedTools = ['Read']
+      const content = await commandExecutor.executeTool('Read', [__filename], allowedTools)
+
+      expect(content).toBeDefined()
+      expect(content).toContain('Command Executor')
+    })
+
+    it('should handle tool errors', async () => {
+      const allowedTools = ['Read']
+
+      await expect(commandExecutor.executeTool('UnknownTool', [], allowedTools)).rejects.toThrow()
+    })
+
+    it('should check permissions before execution', async () => {
+      const allowedTools = ['Read']
+
+      // Bash not allowed
+      await expect(commandExecutor.executeTool('Bash', ['echo test'], allowedTools)).rejects.toThrow(
+        'not allowed'
+      )
+    })
+  })
+
+  describe('executeSimple()', () => {
+    it('should execute simple command', async () => {
+      const executionFn = async (_tools, _context) => {
+        return { message: 'Executed successfully' }
+      }
+
+      const result = await commandExecutor.executeSimple('now', executionFn, testProjectPath)
+
+      expect(result.success).toBe(true)
+      expect(result.result).toEqual({ message: 'Executed successfully' })
+    })
+
+    it('should provide tools to execution function', async () => {
+      const executionFn = async (_tools, _context) => {
+        expect(_tools).toHaveProperty('read')
+        expect(_tools).toHaveProperty('write')
+        expect(_tools).toHaveProperty('bash')
+        return { tools: 'available' }
+      }
+
+      const result = await commandExecutor.executeSimple('now', executionFn, testProjectPath)
+
+      expect(result.success).toBe(true)
+    })
+
+    it('should provide context to execution function', async () => {
+      const executionFn = async (_tools, _context) => {
+        expect(_context).toBeDefined()
+        expect(_context).toHaveProperty('projectId')
+        expect(_context).toHaveProperty('projectPath')
+        return { context: 'received' }
+      }
+
+      const result = await commandExecutor.executeSimple('now', executionFn, testProjectPath)
+
+      expect(result.success).toBe(true)
+    })
+
+    it('should enforce tool permissions', async () => {
+      const executionFn = async (_tools, _context) => {
+        // Try to use a disallowed tool
+        await _tools.write('/test/file.txt', 'content')
+      }
+
+      const result = await commandExecutor.executeSimple('now', executionFn, testProjectPath)
+
+      // Should fail if Write is not in allowed tools for 'now'
+      expect(result.success).toBe(false)
+    })
+
+    it('should handle execution errors', async () => {
+      const executionFn = async (_tools, _context) => {
+        throw new Error('Execution failed')
+      }
+
+      const result = await commandExecutor.executeSimple('now', executionFn, testProjectPath)
+
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('Execution failed')
+    })
+
+    it('should work with allowed tools', async () => {
+      const executionFn = async (_tools, _context) => {
+        // Read is typically allowed
+        const content = await _tools.read(__filename)
+        return { readSuccess: content !== null }
+      }
+
+      const result = await commandExecutor.executeSimple('now', executionFn, testProjectPath)
+
+      expect(result.success).toBe(true)
+      expect(result.result.readSuccess).toBe(true)
+    })
+  })
+
+  describe('Integration', () => {
+    it('should execute full command flow', async () => {
+      const result = await commandExecutor.execute('now', { task: 'Test Task' }, testProjectPath)
+
+      expect(result.success).toBe(true)
+      expect(result.template).toBeDefined()
+      expect(result.context).toBeDefined()
+      expect(result.state).toBeDefined()
+      expect(result.prompt).toBeDefined()
+
+      // Prompt should include the template content
+      expect(result.prompt).toContain(result.template.content)
+
+      // Context should include parameters
+      expect(result.context.params.task).toBe('Test Task')
+    })
+
+    it('should build proper prompt structure', async () => {
+      const result = await commandExecutor.execute('now', {}, testProjectPath)
+
+      expect(result.prompt).toContain('# Command Instructions')
+      expect(result.prompt).toContain('## Project Context')
+      expect(result.prompt).toContain('## Current State')
+      expect(result.prompt).toContain('## Execute')
+    })
+  })
+})

package/core/__tests__/agentic/context-builder.test.js

@@ -0,0 +1,160 @@
+import { describe, it, expect } from 'vitest'
+import contextBuilder from '../../agentic/context-builder.js'
+import path from 'path'
+
+describe('Context Builder', () => {
+  const testProjectPath = process.cwd()
+
+  describe('build()', () => {
+    it('should build context with all required fields', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+
+      expect(context).toBeDefined()
+      expect(context).toHaveProperty('projectId')
+      expect(context).toHaveProperty('projectPath')
+      expect(context).toHaveProperty('globalPath')
+      expect(context).toHaveProperty('paths')
+      expect(context).toHaveProperty('params')
+      expect(context).toHaveProperty('timestamp')
+      expect(context).toHaveProperty('date')
+    })
+
+    it('should include all file paths', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+
+      expect(context.paths).toHaveProperty('now')
+      expect(context.paths).toHaveProperty('next')
+      expect(context.paths).toHaveProperty('context')
+      expect(context.paths).toHaveProperty('shipped')
+      expect(context.paths).toHaveProperty('metrics')
+      expect(context.paths).toHaveProperty('ideas')
+      expect(context.paths).toHaveProperty('roadmap')
+      expect(context.paths).toHaveProperty('memory')
+      expect(context.paths).toHaveProperty('analysis')
+    })
+
+    it('should use correct project path', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+
+      expect(context.projectPath).toBe(testProjectPath)
+    })
+
+    it('should include command parameters', async () => {
+      const params = { taskName: 'test task', feature: 'test feature' }
+      const context = await contextBuilder.build(testProjectPath, params)
+
+      expect(context.params).toEqual(params)
+    })
+
+    it('should include timestamp', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+
+      expect(context.timestamp).toBeDefined()
+      expect(typeof context.timestamp).toBe('string')
+      expect(new Date(context.timestamp).toString()).not.toBe('Invalid Date')
+    })
+
+    it('should include date', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+
+      expect(context.date).toBeDefined()
+      expect(typeof context.date).toBe('string')
+    })
+
+    it('should build global path from project ID', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+
+      expect(context.globalPath).toContain('.prjct-cli')
+      expect(context.globalPath).toContain('projects')
+      expect(context.globalPath).toContain(context.projectId)
+    })
+  })
+
+  describe('loadState()', () => {
+    it('should load state from context', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+      const state = await contextBuilder.loadState(context)
+
+      expect(state).toBeDefined()
+      expect(typeof state).toBe('object')
+    })
+
+    it('should return null for non-existent files', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+      const state = await contextBuilder.loadState(context)
+
+      // Some files might not exist
+      Object.values(state).forEach((value) => {
+        expect(value === null || typeof value === 'string').toBe(true)
+      })
+    })
+
+    it('should load existing files as strings', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+      const state = await contextBuilder.loadState(context)
+
+      // At least some state values should be strings (if files exist)
+      const hasStrings = Object.values(state).some((value) => typeof value === 'string')
+      expect(typeof hasStrings).toBe('boolean')
+    })
+  })
+
+  describe('fileExists()', () => {
+    it('should return true for existing file', async () => {
+      const exists = await contextBuilder.fileExists(__filename)
+
+      expect(exists).toBe(true)
+    })
+
+    it('should return false for non-existent file', async () => {
+      const exists = await contextBuilder.fileExists('/nonexistent/path/file.txt')
+
+      expect(exists).toBe(false)
+    })
+
+    it('should work with package.json', async () => {
+      const packagePath = path.join(process.cwd(), 'package.json')
+      const exists = await contextBuilder.fileExists(packagePath)
+
+      expect(exists).toBe(true)
+    })
+  })
+
+  describe('Path Construction', () => {
+    it('should construct paths with correct structure', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+
+      expect(context.paths.now).toContain('core/now.md')
+      expect(context.paths.next).toContain('core/next.md')
+      expect(context.paths.context).toContain('core/context.md')
+      expect(context.paths.shipped).toContain('progress/shipped.md')
+      expect(context.paths.metrics).toContain('progress/metrics.md')
+      expect(context.paths.ideas).toContain('planning/ideas.md')
+      expect(context.paths.roadmap).toContain('planning/roadmap.md')
+      expect(context.paths.memory).toContain('memory/context.jsonl')
+      expect(context.paths.analysis).toContain('analysis/repo-summary.md')
+    })
+
+    it('should use global path for all file paths', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+
+      Object.values(context.paths).forEach((filePath) => {
+        expect(filePath).toContain(context.globalPath)
+      })
+    })
+  })
+
+  describe('Empty Parameters', () => {
+    it('should handle empty command params', async () => {
+      const context = await contextBuilder.build(testProjectPath, {})
+
+      expect(context.params).toEqual({})
+    })
+
+    it('should handle undefined command params', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+
+      expect(context.params).toEqual({})
+    })
+  })
+})