prjct-cli 0.9.2 → 0.10.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.9.2",
+  "version": "0.10.2",
   "description": "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
   "main": "core/index.js",
   "bin": {
@@ -15,18 +15,14 @@
     "update-commands": "node -e \"const installer = require('./core/infrastructure/command-installer'); installer.syncCommands().then(r => console.log('Commands updated:', r)).catch(e => console.error('Error:', e.message))\"",
     "install-global": "./scripts/install.sh",
     "update": "./scripts/update.sh",
-    "test": "vitest run --workspace=vitest.workspace.js",
-    "test:watch": "vitest --workspace=vitest.workspace.js",
-    "test:coverage": "vitest run --coverage --workspace=vitest.workspace.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
     "validate": "node scripts/validate-commands.js",
-    "lint": "eslint \"**/*.js\" --ignore-pattern \"node_modules/**\" --ignore-pattern \"website/**\"",
-    "lint:fix": "eslint \"**/*.js\" --fix --ignore-pattern \"node_modules/**\" --ignore-pattern \"website/**\"",
+    "lint": "eslint . --ignore-pattern node_modules",
+    "lint:fix": "eslint . --fix --ignore-pattern node_modules",
     "format": "prettier --write \"**/*.{js,jsx,ts,tsx,json,css,md}\" --config .config/.prettierrc --ignore-path .config/.prettierignore",
-    "format:check": "prettier --check \"**/*.{js,jsx,ts,tsx,json,css,md}\" --config .config/.prettierrc --ignore-path .config/.prettierignore",
-    "website:dev": "cd website && npm run dev",
-    "website:build": "cd website && npm run build",
-    "website:preview": "cd website && npm run preview",
-    "website:install": "cd website && npm install"
+    "format:check": "prettier --check \"**/*.{js,jsx,ts,tsx,json,css,md}\" --config .config/.prettierrc --ignore-path .config/.prettierignore"
   },
   "keywords": [
     "claude-code",
@@ -48,7 +44,6 @@
     "prompts": "^2.4.2"
   },
   "devDependencies": {
-    "@types/node": "^20.0.0",
     "@vitest/coverage-v8": "^3.2.4",
     "eslint": "^8.57.1",
     "eslint-config-prettier": "^10.1.8",
@@ -56,10 +51,7 @@
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-n": "^16.6.2",
     "eslint-plugin-promise": "^6.6.0",
-    "jsdom": "^27.0.0",
     "prettier": "^3.6.2",
-    "prettier-plugin-tailwindcss": "^0.6.14",
-    "typescript": "^5.0.0",
     "vitest": "^3.2.4"
   },
   "repository": {
@@ -88,4 +80,4 @@
     "chalk",
     "prompts"
   ]
-}
+}

package/templates/commands/done.md

@@ -1,10 +1,17 @@
 ---
 allowed-tools: [Read, Write]
 description: 'Complete task'
+think-triggers: [report_complete]
 ---
 
 # /p:done
 
+## Think First
+Before marking complete, verify:
+1. Is the task actually finished?
+2. Were all acceptance criteria met?
+3. Should this trigger a /p:ship?
+
 ## Check
 Requires: `core/now.md` has content
 

package/templates/commands/feature.md

@@ -2,10 +2,18 @@
 allowed-tools: [Read, Write, Bash, GetTimestamp, GetDate]
 description: 'Value analysis + roadmap + task breakdown + auto-start'
 timestamp-rule: 'GetTimestamp() and GetDate() for ALL timestamps'
+think-triggers: [explore_to_edit, complex_analysis]
 ---
 
 # /p:feature
 
+## Think First
+Before creating feature, analyze:
+1. Is this a simple or complex feature?
+2. What files/components will be affected?
+3. Are there dependencies or blockers?
+4. Should I create a /p:spec first?
+
 ## Flow
 
 1. **Value**: Impact/effort/timing → do_now/defer/blocked

package/templates/commands/ship.md

@@ -2,10 +2,18 @@
 allowed-tools: [Read, Write, Bash, GetTimestamp, GetDate]
 description: 'Ship feature workflow'
 timestamp-rule: 'GetTimestamp() and GetDate() for timestamps'
+think-triggers: [git_decision, report_complete]
 ---
 
 # /p:ship
 
+## Think First
+Before shipping, verify:
+1. Are there uncommitted changes to include?
+2. What version bump is needed (patch/minor/major)?
+3. Is the feature actually complete?
+4. Should tests run first?
+
 ## Workflow (non-blocking)
 1. Lint → Tests → Docs update
 2. Version bump → CHANGELOG

package/templates/commands/spec.md

@@ -0,0 +1,128 @@
+---
+allowed-tools: [Read, Write, Glob, GetTimestamp, GetDate]
+description: 'Spec-driven development for complex features'
+timestamp-rule: 'GetTimestamp() and GetDate() for ALL timestamps'
+think-triggers: [explore_to_edit, complex_analysis]
+---
+
+# /p:spec
+
+Spec-Driven Development. Creates detailed specifications for complex features before implementation.
+
+## Think First
+Before creating spec, analyze:
+1. Is this feature complex enough for a spec? (auth, payments, migrations = yes)
+2. What are the key architectural decisions to make?
+3. Are there multiple valid approaches? Document tradeoffs.
+4. What questions should I ask the user before proceeding?
+
+## Purpose
+
+For features that require:
+- Clear requirements before coding
+- Design decisions documented
+- Tasks broken into 20-30 min chunks
+- User approval before starting
+
+## Flow
+
+### No params: Show template
+```
+→ Interactive spec template
+→ Ask for feature name
+→ Guide through requirements
+```
+
+### With feature name: Create spec
+```
+/p:spec "Dark Mode"
+1. Analyze: Context, patterns, dependencies
+2. Propose: Requirements + Design + Tasks
+3. Write: `planning/specs/{slug}.md`
+4. Ask: User approval
+5. On approve: Add tasks to queue, start first
+```
+
+## Spec Structure
+
+```markdown
+# Feature Spec: {name}
+
+**Created**: {GetDate()}
+**Status**: PENDING_APPROVAL | APPROVED | IN_PROGRESS | COMPLETED
+
+## Requirements (User approves)
+- [ ] Requirement 1
+- [ ] Requirement 2
+- [ ] Requirement 3
+
+## Design (Claude proposes)
+- **Approach**: {architecture decision}
+- **Key decisions**: {list}
+- **Dependencies**: {existing code/libs}
+
+## Tasks (20-30min each)
+1. [ ] Task 1 (20m) - {description}
+2. [ ] Task 2 (25m) - {description}
+3. [ ] Task 3 (30m) - {description}
+
+**Total**: {n} tasks, ~{Xh}
+
+## Notes
+- {implementation notes}
+- {edge cases to consider}
+```
+
+## Validation
+
+- Feature name required for creation
+- Spec must have at least 1 requirement
+- Each task should be 20-30 minutes
+- Check for existing spec with same name
+
+## Data
+
+Session: `{"ts":"{GetTimestamp()}","type":"spec_create","name":"{feature}","requirements":{n},"tasks":{n},"effort":"{Xh}"}`
+Spec file: `planning/specs/{feature-slug}.md`
+
+## Response
+
+### On creation:
+```
+📋 Spec: {feature}
+
+Requirements ({n}):
+{numbered_list}
+
+Design:
+→ {approach}
+→ {key_decision}
+
+Tasks ({n}, ~{total_time}):
+{numbered_list}
+
+APPROVE? (y/n/edit)
+```
+
+### On approval:
+```
+✅ Spec approved: {feature}
+→ {n} tasks added to queue
+→ Starting: {task_1}
+
+Use /p:done when complete
+```
+
+## Examples
+
+```
+/p:spec "User Authentication"
+→ Creates spec with OAuth/JWT decisions
+→ Breaks into: setup, login, logout, session, tests
+→ Estimates ~4h total
+
+/p:spec "Dark Mode"
+→ Creates spec with theme approach
+→ Breaks into: toggle, state, styles, persist, test
+→ Estimates ~3h total
+```

package/templates/global/CLAUDE.md

@@ -5,6 +5,23 @@ This section provides global context for all `/p:*` commands across any prjct pr
 
 **Auto-managed by prjct-cli** - This section is automatically updated when you install or update prjct.
 
+## 🤖 Project Context (OBLIGATORIO)
+
+**ANTES de trabajar en un proyecto prjct, LEE el contexto del proyecto:**
+
+1. Lee `.prjct/prjct.config.json` → obtén `projectId`
+2. Lee `~/.prjct-cli/projects/{projectId}/CLAUDE.md` → contexto dinámico del proyecto
+3. Para detalles de implementación, lee los archivos en `agents/`
+
+El archivo `CLAUDE.md` del proyecto contiene:
+- Stack detectado del proyecto
+- Agentes disponibles (varían por proyecto)
+- Tarea actual
+- Cola de prioridades
+- Rutas a documentación detallada
+
+**Si no existe CLAUDE.md**: Sugiere ejecutar `/p:sync` para generarlo.
+
 ## 🎯 Path Resolution for ALL /p:* Commands
 
 **CRITICAL**: Every `/p:*` command operates on **global storage**, NOT local files.

package/core/__tests__/agentic/agent-router.test.js

@@ -1,398 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest'
-import { createRequire } from 'module'
-import path from 'path'
-import fs from 'fs/promises'
-import os from 'os'
-
-const require = createRequire(import.meta.url)
-
-describe('Mandatory Agent Router', () => {
-  let MandatoryAgentRouter
-  let AgentGenerator
-  let router
-  let mockAgentGenerator
-
-  beforeEach(() => {
-    MandatoryAgentRouter = require('../../agentic/agent-router.js')
-    AgentGenerator = require('../../domain/agent-generator.js')
-    
-    // Mock agent generator
-    mockAgentGenerator = {
-      generateDynamicAgent: vi.fn().mockResolvedValue({
-        name: 'test-agent',
-        type: 'frontend-specialist',
-        domain: 'frontend',
-        confidence: 0.9
-      })
-    }
-
-    router = new MandatoryAgentRouter()
-    router.agentGenerator = mockAgentGenerator
-  })
-
-  describe('Constructor', () => {
-    it('should initialize with agent generator', () => {
-      expect(router.agentGenerator).toBeDefined()
-      expect(router.agentCache).toBeInstanceOf(Map)
-      expect(Array.isArray(router.usageLog)).toBe(true)
-    })
-  })
-
-  describe('executeTask()', () => {
-    it('should assign agent to task', async () => {
-      const task = { description: 'create login component', type: 'ui' }
-      const context = { projectPath: '/test', files: [] }
-      const projectPath = '/test'
-
-      const result = await router.executeTask(task, context, projectPath)
-
-      expect(result).toBeDefined()
-      expect(result.agent).toBeDefined()
-      expect(result.agent.name).toBe('test-agent')
-      expect(result.context).toBeDefined()
-      expect(result.taskAnalysis).toBeDefined()
-      expect(result.routing).toBeDefined()
-    })
-
-    it('should throw error if no agent can be assigned', async () => {
-      router.agentGenerator.generateDynamicAgent = vi.fn().mockResolvedValue(null)
-      
-      const task = { description: 'unknown task' }
-      const context = { projectPath: '/test' }
-      const projectPath = '/test'
-
-      await expect(router.executeTask(task, context, projectPath)).rejects.toThrow('CRITICAL: No agent assigned')
-    })
-
-    it('should cache agents for reuse', async () => {
-      const task = { description: 'create component', type: 'ui' }
-      const context = { projectPath: '/test' }
-      const projectPath = '/test'
-
-      await router.executeTask(task, context, projectPath)
-      await router.executeTask(task, context, projectPath)
-
-      // Should only generate once, second call uses cache
-      expect(mockAgentGenerator.generateDynamicAgent).toHaveBeenCalledTimes(1)
-    })
-
-    it('should log agent usage', async () => {
-      const task = { description: 'test task' }
-      const context = { projectPath: '/test', files: ['file1.js', 'file2.js'] }
-      const projectPath = '/test'
-
-      await router.executeTask(task, context, projectPath)
-
-      expect(router.usageLog.length).toBeGreaterThan(0)
-      expect(router.usageLog[0].task).toBe('test task')
-      expect(router.usageLog[0].agent).toBe('test-agent')
-    })
-  })
-
-  describe('analyzeTask()', () => {
-    it('should detect frontend tasks', () => {
-      const task = { description: 'create react component with styles' }
-      const analysis = router.analyzeTask(task)
-
-      expect(analysis.domain).toBe('frontend')
-      expect(analysis.confidence).toBeGreaterThan(0)
-      expect(analysis.matchedKeywords.length).toBeGreaterThan(0)
-    })
-
-    it('should detect backend tasks', () => {
-      const task = { description: 'create API endpoint with authentication' }
-      const analysis = router.analyzeTask(task)
-
-      expect(analysis.domain).toBe('backend')
-      expect(analysis.matchedKeywords).toContain('api')
-    })
-
-    it('should detect database tasks', () => {
-      const task = { description: 'create migration schema for postgres' }
-      const analysis = router.analyzeTask(task)
-
-      expect(analysis.domain).toBe('database')
-      expect(analysis.matchedKeywords).toContain('migration')
-    })
-
-    it('should detect devops tasks', () => {
-      const task = { description: 'deploy to docker kubernetes' }
-      const analysis = router.analyzeTask(task)
-
-      expect(analysis.domain).toBe('devops')
-    })
-
-    it('should detect qa tasks', () => {
-      const task = { description: 'write unit tests and fix bugs' }
-      const analysis = router.analyzeTask(task)
-
-      expect(analysis.domain).toBe('qa')
-    })
-
-    it('should detect architecture tasks', () => {
-      const task = { description: 'design architecture pattern and refactor' }
-      const analysis = router.analyzeTask(task)
-
-      expect(analysis.domain).toBe('architecture')
-    })
-
-    it('should return generalist for unknown tasks', () => {
-      const task = { description: 'random task description' }
-      const analysis = router.analyzeTask(task)
-
-      expect(analysis.domain).toBe('generalist')
-      expect(analysis.confidence).toBeLessThan(1)
-    })
-
-    it('should include technology stack in analysis', () => {
-      const task = { description: 'create react component with typescript' }
-      const analysis = router.analyzeTask(task)
-
-      expect(analysis.techStack).toBeDefined()
-      expect(analysis.techStack.languages).toContain('typescript')
-      expect(analysis.techStack.frameworks).toContain('react')
-    })
-  })
-
-  describe('detectTechnology()', () => {
-    it('should detect languages', () => {
-      const task = { description: 'write python script' }
-      const tech = router.detectTechnology(task, task.description)
-
-      expect(tech.languages).toContain('python')
-    })
-
-    it('should detect frameworks', () => {
-      const task = { description: 'build express api' }
-      const tech = router.detectTechnology(task, task.description)
-
-      expect(tech.frameworks).toContain('express')
-    })
-
-    it('should detect databases', () => {
-      const task = { description: 'query mongodb database' }
-      const tech = router.detectTechnology(task, task.description)
-
-      expect(tech.databases).toContain('mongodb')
-    })
-
-    it('should return empty arrays for unknown tech', () => {
-      const task = { description: 'random task' }
-      const tech = router.detectTechnology(task, task.description)
-
-      expect(tech.languages).toEqual([])
-      expect(tech.frameworks).toEqual([])
-      expect(tech.databases).toEqual([])
-    })
-  })
-
-  describe('assignAgent()', () => {
-    it('should generate agent for task', async () => {
-      const taskAnalysis = {
-        domain: 'frontend',
-        techStack: { languages: ['typescript'], frameworks: ['react'] }
-      }
-      const context = { projectPath: '/test' }
-
-      const agent = await router.assignAgent(taskAnalysis, context)
-
-      expect(agent).toBeDefined()
-      expect(mockAgentGenerator.generateDynamicAgent).toHaveBeenCalled()
-    })
-
-    it('should use cached agent if available', async () => {
-      const taskAnalysis = {
-        domain: 'frontend',
-        techStack: { languages: ['typescript'] }
-      }
-      const context = { projectPath: '/test' }
-
-      const agent1 = await router.assignAgent(taskAnalysis, context)
-      const agent2 = await router.assignAgent(taskAnalysis, context)
-
-      expect(agent1).toBe(agent2) // Same instance from cache
-      expect(mockAgentGenerator.generateDynamicAgent).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  describe('filterContextForAgent()', () => {
-    it('should filter context for frontend agent', async () => {
-      const agent = { name: 'frontend-agent', domain: 'frontend' }
-      const fullContext = {
-        files: [
-          'src/components/Button.jsx',
-          'src/api/users.js',
-          'src/styles/main.css',
-          'migrations/001_users.sql'
-        ]
-      }
-      const taskAnalysis = { domain: 'frontend' }
-
-      const filtered = await router.filterContextForAgent(agent, fullContext, taskAnalysis)
-
-      expect(filtered.files).toContain('src/components/Button.jsx')
-      expect(filtered.files).toContain('src/styles/main.css')
-      expect(filtered.files).not.toContain('migrations/001_users.sql')
-      expect(filtered.relevantOnly).toBe(true)
-    })
-
-    it('should filter context for backend agent', async () => {
-      const agent = { name: 'backend-agent', domain: 'backend' }
-      const fullContext = {
-        files: [
-          'src/components/Button.jsx',
-          'src/api/users.js',
-          'src/routes/auth.js',
-          'src/styles/main.css'
-        ]
-      }
-      const taskAnalysis = { domain: 'backend' }
-
-      const filtered = await router.filterContextForAgent(agent, fullContext, taskAnalysis)
-
-      expect(filtered.files).toContain('src/api/users.js')
-      expect(filtered.files).toContain('src/routes/auth.js')
-      expect(filtered.files).not.toContain('src/styles/main.css')
-    })
-
-    it('should filter context for database agent', async () => {
-      const agent = { name: 'database-agent', domain: 'database' }
-      const fullContext = {
-        files: [
-          'src/models/User.js',
-          'migrations/001_users.sql',
-          'src/components/Button.jsx'
-        ]
-      }
-      const taskAnalysis = { domain: 'database' }
-
-      const filtered = await router.filterContextForAgent(agent, fullContext, taskAnalysis)
-
-      expect(filtered.files).toContain('src/models/User.js')
-      expect(filtered.files).toContain('migrations/001_users.sql')
-      expect(filtered.files).not.toContain('src/components/Button.jsx')
-    })
-  })
-
-  describe('filterFiles()', () => {
-    it('should exclude files matching exclude patterns', () => {
-      const files = ['src/app.js', 'node_modules/lib.js', 'dist/bundle.js']
-      const pattern = {
-        include: [],
-        exclude: ['node_modules', 'dist'],
-        extensions: []
-      }
-
-      const filtered = router.filterFiles(files, pattern)
-
-      expect(filtered).not.toContain('node_modules/lib.js')
-      expect(filtered).not.toContain('dist/bundle.js')
-      expect(filtered).toContain('src/app.js')
-    })
-
-    it('should include only files matching include patterns', () => {
-      const files = ['src/components/Button.jsx', 'src/api/users.js', 'tests/test.js']
-      const pattern = {
-        include: ['components'],
-        exclude: [],
-        extensions: []
-      }
-
-      const filtered = router.filterFiles(files, pattern)
-
-      expect(filtered).toContain('src/components/Button.jsx')
-      expect(filtered).not.toContain('src/api/users.js')
-    })
-
-    it('should filter by extensions', () => {
-      const files = ['src/app.js', 'src/app.ts', 'src/app.py']
-      const pattern = {
-        include: [],
-        exclude: [],
-        extensions: ['.js', '.ts']
-      }
-
-      const filtered = router.filterFiles(files, pattern)
-
-      expect(filtered).toContain('src/app.js')
-      expect(filtered).toContain('src/app.ts')
-      expect(filtered).not.toContain('src/app.py')
-    })
-  })
-
-  describe('getBestPractices()', () => {
-    it('should return domain-specific practices', async () => {
-      const practices = await router.getBestPractices('frontend', { languages: [], frameworks: [] })
-
-      expect(practices.length).toBeGreaterThan(0)
-      expect(practices).toContain('Component composition over inheritance')
-    })
-
-    it('should include tech-specific practices', async () => {
-      const practices = await router.getBestPractices('frontend', {
-        languages: ['typescript'],
-        frameworks: ['react']
-      })
-
-      expect(practices.some(p => p.includes('Hooks') || p.includes('TypeScript'))).toBe(true)
-    })
-  })
-
-  describe('getSimilarDomains()', () => {
-    it('should return similar domains for frontend', () => {
-      const similar = router.getSimilarDomains('frontend')
-      expect(similar).toContain('fullstack')
-    })
-
-    it('should return similar domains for backend', () => {
-      const similar = router.getSimilarDomains('backend')
-      expect(similar).toContain('fullstack')
-    })
-
-    it('should return default for unknown domain', () => {
-      const similar = router.getSimilarDomains('unknown')
-      expect(similar).toEqual(['generalist'])
-    })
-  })
-
-  describe('getUsageStats()', () => {
-    it('should return usage statistics', async () => {
-      const task = { description: 'test task' }
-      const context = { projectPath: '/test' }
-      const projectPath = '/test'
-
-      await router.executeTask(task, context, projectPath)
-      await router.executeTask(task, context, projectPath)
-
-      const stats = router.getUsageStats()
-
-      expect(stats.totalTasks).toBe(2)
-      expect(stats.byAgent).toBeDefined()
-      expect(stats.mostUsedAgent).toBe('test-agent')
-    })
-
-    it('should handle empty usage log', () => {
-      const stats = router.getUsageStats()
-
-      expect(stats.totalTasks).toBe(0)
-      expect(stats.mostUsedAgent).toBeNull()
-    })
-  })
-
-  describe('calculateContextReduction()', () => {
-    it('should calculate reduction for filtered context', () => {
-      const filteredContext = { relevantOnly: true }
-      const reduction = router.calculateContextReduction(filteredContext)
-
-      expect(reduction).toBe('70-90%')
-    })
-
-    it('should return 0% for unfiltered context', () => {
-      const context = { relevantOnly: false }
-      const reduction = router.calculateContextReduction(context)
-
-      expect(reduction).toBe('0%')
-    })
-  })
-})
-