prjct-cli 0.5.0 → 0.6.0

package/core/task-schema.js

@@ -0,0 +1,342 @@
+/**
+ * Task Metadata Schema and Agent Types
+ *
+ * Defines the structure for task tracking with agent assignment,
+ * time estimation, and complexity scoring.
+ *
+ * @version 0.6.0
+ */
+
+/**
+ * Agent Types - Technical specialists for task assignment
+ */
+const AGENT_TYPES = {
+  'backend-architect': {
+    name: 'Backend Architect',
+    specialization: 'Server-side architecture, APIs, databases',
+    keywords: ['api', 'backend', 'server', 'database', 'endpoint', 'migration', 'schema'],
+    icon: '🏗️',
+    estimatedEfficiency: 1.0, // baseline
+  },
+  'frontend-developer': {
+    name: 'Frontend Developer',
+    specialization: 'UI/UX, components, responsive design',
+    keywords: ['ui', 'frontend', 'component', 'design', 'layout', 'responsive', 'css', 'style'],
+    icon: '🎨',
+    estimatedEfficiency: 1.0,
+  },
+  'fullstack-engineer': {
+    name: 'Fullstack Engineer',
+    specialization: 'End-to-end feature development',
+    keywords: ['fullstack', 'feature', 'integration', 'end-to-end', 'complete'],
+    icon: '⚡',
+    estimatedEfficiency: 0.9, // slightly slower due to context switching
+  },
+  'devops-specialist': {
+    name: 'DevOps Specialist',
+    specialization: 'CI/CD, deployment, infrastructure',
+    keywords: ['deploy', 'ci/cd', 'docker', 'kubernetes', 'infrastructure', 'pipeline', 'build'],
+    icon: '🚀',
+    estimatedEfficiency: 1.1, // faster at automation
+  },
+  'security-engineer': {
+    name: 'Security Engineer',
+    specialization: 'Authentication, authorization, security',
+    keywords: [
+      'auth',
+      'security',
+      'authentication',
+      'authorization',
+      'encryption',
+      'jwt',
+      'oauth',
+    ],
+    icon: '🔒',
+    estimatedEfficiency: 0.8, // slower due to thorough security review
+  },
+  'data-engineer': {
+    name: 'Data Engineer',
+    specialization: 'Data processing, analytics, ETL',
+    keywords: ['data', 'analytics', 'etl', 'pipeline', 'processing', 'warehouse', 'query'],
+    icon: '📊',
+    estimatedEfficiency: 0.9,
+  },
+  'qa-engineer': {
+    name: 'QA Engineer',
+    specialization: 'Testing, quality assurance, automation',
+    keywords: ['test', 'testing', 'qa', 'quality', 'automation', 'e2e', 'integration'],
+    icon: '🧪',
+    estimatedEfficiency: 1.0,
+  },
+  'performance-engineer': {
+    name: 'Performance Engineer',
+    specialization: 'Optimization, scaling, performance',
+    keywords: ['performance', 'optimize', 'scaling', 'cache', 'speed', 'bottleneck'],
+    icon: '⚡',
+    estimatedEfficiency: 0.85, // slower due to profiling and measurement
+  },
+  'general-developer': {
+    name: 'General Developer',
+    specialization: 'General-purpose development',
+    keywords: ['fix', 'update', 'improve', 'refactor', 'cleanup'],
+    icon: '👨‍💻',
+    estimatedEfficiency: 1.0,
+  },
+}
+
+/**
+ * Complexity Levels
+ */
+const COMPLEXITY = {
+  trivial: {
+    level: 1,
+    name: 'Trivial',
+    description: 'Simple changes, typos, configuration',
+    estimatedHours: 0.5,
+    multiplier: 0.5,
+    examples: ['Fix typo', 'Update config value', 'Change color'],
+  },
+  simple: {
+    level: 2,
+    name: 'Simple',
+    description: 'Straightforward implementation, single file',
+    estimatedHours: 2,
+    multiplier: 1.0,
+    examples: ['Add validation', 'Create simple component', 'Update documentation'],
+  },
+  moderate: {
+    level: 3,
+    name: 'Moderate',
+    description: 'Multiple files, some complexity',
+    estimatedHours: 4,
+    multiplier: 2.0,
+    examples: ['Implement new feature', 'Refactor module', 'Add API endpoint'],
+  },
+  complex: {
+    level: 4,
+    name: 'Complex',
+    description: 'System-wide changes, architecture',
+    estimatedHours: 8,
+    multiplier: 4.0,
+    examples: ['Authentication system', 'Database migration', 'Performance optimization'],
+  },
+  epic: {
+    level: 5,
+    name: 'Epic',
+    description: 'Major feature, multiple systems',
+    estimatedHours: 16,
+    multiplier: 8.0,
+    examples: ['Payment integration', 'Real-time messaging', 'Admin dashboard'],
+  },
+}
+
+/**
+ * Task Status
+ */
+const TASK_STATUS = {
+  pending: 'Waiting to start',
+  active: 'Currently working on',
+  blocked: 'Blocked by dependency',
+  completed: 'Successfully finished',
+  cancelled: 'Cancelled/discarded',
+}
+
+/**
+ * Task Schema
+ */
+class TaskSchema {
+  /**
+   * Create a new task
+   */
+  static create(data) {
+    const now = new Date().toISOString()
+
+    return {
+      id: data.id || this.generateId(),
+      title: data.title,
+      description: data.description || null,
+
+      // Agent & Developer
+      assignedAgent: data.assignedAgent || this.detectAgent(data.title),
+      githubDev: data.githubDev || null, // Will be populated from git config
+
+      // Complexity & Time
+      complexity: data.complexity || this.estimateComplexity(data.title, data.description),
+      estimatedTime: data.estimatedTime || this.estimateTime(data.complexity),
+      actualTime: null,
+
+      // Status & Tracking
+      status: data.status || 'pending',
+      priority: data.priority || 5,
+      blocked: data.blocked || false,
+      blockedBy: data.blockedBy || null,
+
+      // Timestamps
+      createdAt: data.createdAt || now,
+      startedAt: data.startedAt || null,
+      completedAt: data.completedAt || null,
+
+      // Metadata
+      tags: data.tags || [],
+      notes: data.notes || null,
+    }
+  }
+
+  /**
+   * Generate unique task ID
+   */
+  static generateId() {
+    return `task-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
+  }
+
+  /**
+   * Auto-detect appropriate agent based on task description
+   */
+  static detectAgent(title, description = '') {
+    const text = `${title} ${description}`.toLowerCase()
+    let bestMatch = 'general-developer'
+    let highestScore = 0
+
+    for (const [agentType, config] of Object.entries(AGENT_TYPES)) {
+      const score = config.keywords.filter((keyword) => text.includes(keyword)).length
+
+      if (score > highestScore) {
+        highestScore = score
+        bestMatch = agentType
+      }
+    }
+
+    return bestMatch
+  }
+
+  /**
+   * Estimate complexity based on keywords and description
+   */
+  static estimateComplexity(title, description = '') {
+    const text = `${title} ${description}`.toLowerCase()
+
+    // Epic indicators
+    if (
+      text.match(
+        /system|payment|real-time|dashboard|integration|authentication|migration|architecture/i,
+      )
+    ) {
+      return 'epic'
+    }
+
+    // Complex indicators
+    if (text.match(/refactor|optimization|security|database|multiple|complex/i)) {
+      return 'complex'
+    }
+
+    // Moderate indicators
+    if (text.match(/feature|implement|api|endpoint|component|module/i)) {
+      return 'moderate'
+    }
+
+    // Simple indicators
+    if (text.match(/add|update|fix|change|simple|small/i)) {
+      return 'simple'
+    }
+
+    // Trivial indicators
+    if (text.match(/typo|config|color|text|minor|tiny/i)) {
+      return 'trivial'
+    }
+
+    return 'simple' // default
+  }
+
+  /**
+   * Estimate time based on complexity and agent efficiency
+   */
+  static estimateTime(complexity, agentType = 'general-developer') {
+    const complexityData = COMPLEXITY[complexity]
+    const agentData = AGENT_TYPES[agentType]
+
+    if (!complexityData || !agentData) {
+      return '2-4 hours'
+    }
+
+    const baseHours = complexityData.estimatedHours
+    const adjustedHours = baseHours * agentData.estimatedEfficiency
+
+    // Format as range
+    const low = Math.floor(adjustedHours * 0.75)
+    const high = Math.ceil(adjustedHours * 1.25)
+
+    if (adjustedHours < 1) {
+      return `${Math.round(adjustedHours * 60)} minutes`
+    }
+
+    return `${low}-${high} hours`
+  }
+
+  /**
+   * Start a task (move to active)
+   */
+  static start(task) {
+    return {
+      ...task,
+      status: 'active',
+      startedAt: new Date().toISOString(),
+    }
+  }
+
+  /**
+   * Complete a task
+   */
+  static complete(task) {
+    const completedAt = new Date().toISOString()
+    const actualTime = this.calculateActualTime(task.startedAt, completedAt)
+
+    return {
+      ...task,
+      status: 'completed',
+      completedAt,
+      actualTime,
+    }
+  }
+
+  /**
+   * Calculate actual time spent
+   */
+  static calculateActualTime(startedAt, completedAt) {
+    if (!startedAt) return null
+
+    const start = new Date(startedAt)
+    const end = new Date(completedAt)
+    const diffMs = end - start
+    const hours = Math.floor(diffMs / (1000 * 60 * 60))
+    const minutes = Math.floor((diffMs % (1000 * 60 * 60)) / (1000 * 60))
+
+    if (hours === 0) {
+      return `${minutes}m`
+    }
+    return `${hours}h ${minutes}m`
+  }
+
+  /**
+   * Validate task schema
+   */
+  static validate(task) {
+    const errors = []
+
+    if (!task.title) errors.push('Task title is required')
+    if (!AGENT_TYPES[task.assignedAgent]) errors.push('Invalid agent type')
+    if (!COMPLEXITY[task.complexity]) errors.push('Invalid complexity level')
+    if (!TASK_STATUS[task.status]) errors.push('Invalid task status')
+
+    return {
+      valid: errors.length === 0,
+      errors,
+    }
+  }
+}
+
+module.exports = {
+  TaskSchema,
+  AGENT_TYPES,
+  COMPLEXITY,
+  TASK_STATUS,
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
   "main": "core/index.js",
   "bin": {
@@ -15,6 +15,7 @@
     "preuninstall": "node scripts/preuninstall.js",
     "install-global": "./scripts/install.sh",
     "test": "echo 'No tests configured'",
+    "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/**\"",
     "format": "prettier --write \"**/*.{js,jsx,ts,tsx,json,css,md}\" --config .config/.prettierrc --ignore-path .config/.prettierignore",
@@ -36,7 +37,7 @@
     "no-bs",
     "focus"
   ],
-  "author": "prjct.dev",
+  "author": "prjct.app",
   "license": "MIT",
   "dependencies": {
     "chalk": "^4.1.2",
@@ -62,7 +63,7 @@
   "bugs": {
     "url": "https://github.com/jlopezlira/prjct-cli/issues"
   },
-  "homepage": "https://prjct.dev",
+  "homepage": "https://prjct.app",
   "engines": {
     "node": ">=18.0.0"
   },

package/templates/agents/AGENTS.md

@@ -1,33 +1,38 @@
 # AGENTS.md
 
-AI assistant guidance for prjct-cli.
+AI assistant guidance for **prjct-cli** - developer momentum tool for solo builders & small teams (2-5 people). Just ship. No BS.
+
+## What This Is
+
+**NOT** project management. NO sprints, story points, ceremonies, or meetings.
+
+**IS** frictionless progress tracking. Talk naturally, ship features, celebrate wins.
 
 ## Talk Naturally
 
-**You don't need to memorize commands** - just describe what you want to do!
+**Zero memorization** - just describe what you want!
 
-The AI assistant uses **semantic understanding** to map your intent to commands. Works in **any language** the LLM understands (primarily English and Spanish).
+Works in **any language** via semantic understanding.
 
 **Examples:**
 ```
-Intent: Start working on something
+Start working:
 → "I want to build the login page"
-→ "Let me work on authentication"
 → "Voy a hacer el dashboard"
 → Command: /p:now
 
-Intent: Finished current work
-→ "I'm done" | "finished" | "terminé" | "completed"
+Finished:
+→ "I'm done" | "terminé" | "completed"
 → Command: /p:done
 
-Intent: Ship a feature
+Ship:
 → "ship this" | "deploy it" | "ready to launch"
 → Command: /p:ship
 ```
 
-**Both work simultaneously:**
-- Talk naturally: "I want to start building auth"
-- Use commands directly: `/p:now "building auth"`
+**Both work:**
+- Natural: "I want to start building auth"
+- Direct: `/p:now "building auth"`
 
 ## Architecture
 
@@ -42,123 +47,96 @@ memory/      # context.jsonl
 
 **Local**: `.prjct/prjct.config.json`
 
-## MCP Servers
-
-- **Context7**: Library docs (always on)
-- **Filesystem**: File ops
-- **Memory**: Persistence
-- **Sequential**: Complex reasoning
-
 ## Quick Start
 
-1. Initialize: `/p:init`
-2. Type: `/p:help` for interactive guide
-3. Or just talk: "I want to start [task]"
+1. `/p:init` - Initialize
+2. `/p:help` - Guide
+3. Or talk: "I want to start [task]"
 
 ## Commands
 
-**💡 Tip**: Type `/p:help` anytime for an interactive guide with natural language options.
-
-| Command | Say This Instead | Action |
-|---------|------------------|--------|
-| `/p:help` | "help" or "what can I do?" | Interactive guide |
-| `/p:init` | - | Create global dirs + config |
-| `/p:now [task]` | "start [task]" | Update `core/now.md` |
-| `/p:done` | "I'm done" or "finished" | Clear focus, suggest next |
-| `/p:ship <feature>` | "ship [feature]" | Add to `progress/shipped.md` |
-| `/p:next` | "what's next?" | Read `core/next.md` |
-| `/p:idea <text>` | "I have an idea about [x]" | Append to `planning/ideas.md` |
-| `/p:recap` | "show my progress" | Aggregate all metrics |
-| `/p:progress [period]` | "how am I doing?" | Filter by timeframe |
-| `/p:stuck <issue>` | "I'm stuck on [issue]" | Context-based guidance |
-| `/p:context` | "show project context" | Display config + activity |
-| `/p:roadmap` | "show the plan" | Read `planning/roadmap.md` |
-| `/p:analyze` | "analyze this repo" | Generate `analysis/repo-summary.md` |
-| `/p:task` | "break this down" | Multi-step execution |
-| `/p:git` | - | Smart commits with context |
-| `/p:fix` | "help me fix [x]" | Quick problem solving |
-| `/p:test` | "run tests" | Execute + report |
-| `/p:design` | "design [x]" | Generate diagrams + specs |
-| `/p:cleanup` | "clean up code" | Remove dead code/deps |
+**💡 Tip**: `/p:help` for interactive guide
+
+| Command | Say This | Action |
+|---------|----------|--------|
+| `/p:help` | "help" | Interactive guide |
+| `/p:init` | - | Create structure |
+| `/p:now [task]` | "start [task]" | Set current task |
+| `/p:done` | "I'm done" | Complete & next |
+| `/p:ship <feature>` | "ship [feature]" | Celebrate win |
+| `/p:next` | "what's next?" | Show queue |
+| `/p:idea <text>` | "idea about [x]" | Capture ideas |
+| `/p:recap` | "show progress" | Overview |
+| `/p:progress [period]` | "how am I doing?" | Metrics |
+| `/p:stuck <issue>` | "I'm stuck" | Get help |
+| `/p:context` | "show context" | Display state |
+| `/p:analyze` | "analyze repo" | Generate summary |
+| `/p:design` | "design [x]" | Generate specs |
+| `/p:cleanup` | "clean up" | Remove dead code |
 
 ## How It Works
 
-**You can talk naturally:**
-- System detects intent from your message
-- Maps to appropriate command automatically
-- Responds conversationally with options
-- Always suggests what to do next
-
-**Every response includes:**
-- What you just did
-- Natural language options for next steps
-- Command alternatives if you prefer
-
-**Zero memorization needed** - just describe what you want!
+**Natural conversation:**
+- Detect intent
+- Map to command
+- Respond with options
+- Suggest next steps
 
-## Natural Language Detection
+**Every response:**
+- What you did
+- Natural options
+- Command alternatives
 
-The AI assistant uses **semantic understanding** to map user intent to commands.
+**Zero memorization!**
 
-### How It Works
+## Intent Detection
 
-**You're an LLM** - use your natural language understanding, not pattern matching!
+Semantic understanding, not pattern matching.
 
-1. **Check if direct command**: Does message start with `/p:`? → Execute directly
-2. **Understand user intent**: What is the user trying to accomplish?
-3. **Map to appropriate command**: Based on semantic meaning
-4. **Extract parameters**: Pull relevant information from the message
-5. **Show transparency**: Always say what you understood and what you'll execute
+| Intent | Command | Examples |
+|--------|---------|----------|
+| Start task | `/p:now` | "work on X", "starting API", "voy a hacer X" |
+| Finish | `/p:done` | "done", "finished", "terminé", "listo" |
+| Ship | `/p:ship` | "ship this", "deploy X", "it's ready" |
+| Idea | `/p:idea` | "I have an idea", "what if we..." |
+| Progress | `/p:recap` | "show progress", "how am I doing" |
+| Stuck | `/p:stuck` | "I'm stuck", "help with X" |
+| Next | `/p:next` | "what's next", "qué sigue" |
 
-### Command Intent Map
+**Any language works** - if you understand intent, execute the command.
 
-| User Intent | Command | Examples of Natural Expression |
-|-------------|---------|-------------------------------|
-| Start/focus on task | `/p:now` | "let me work on X", "starting the API", "voy a hacer X" |
-| Finished current work | `/p:done` | "done", "finished", "terminé", "completed", "listo" |
-| Ship/deploy feature | `/p:ship` | "ship this", "deploy X", "it's ready", "let's launch" |
-| Capture an idea | `/p:idea` | "I have an idea", "what if we...", "tengo una idea" |
-| Check progress/status | `/p:recap` | "show progress", "how am I doing", "muéstrame el avance" |
-| Stuck on problem | `/p:stuck` | "I'm stuck", "help with X", "estoy atascado" |
-| What to work on next | `/p:next` | "what's next", "qué sigue", "what should I do" |
-
-**Key principle**: If you understand what the user wants, map it to the right command. Don't rely on exact phrase matching.
-
-### Example Flow
+### Example
 
 **User:** "I want to start building the login page"
 
-**Your Reasoning:**
-- Intent detected: User wants to begin working on something
-- Appropriate command: `/p:now`
-- Parameter to extract: "building the login page"
+**Your reasoning:**
+- Intent: Start working
+- Command: `/p:now`
+- Param: "building the login page"
 
-**Your Response:**
+**Response:**
 ```
-💬 I understood: "start working on building the login page"
+💬 Understood: "start building the login page"
 ⚡ Executing: /p:now "building the login page"
 
-✅ Starting task: building the login page
+✅ Starting: building the login page
 
-What's next?
+Next:
 • Say "I'm done" when finished
 • Or: /p:done
 ```
 
-### Works in Any Language
-
-If you understand the user's intent in **any language**, execute the command:
-- English: "I want to start the API"
-- Spanish: "Quiero empezar con la autenticación"
-- Casual: "gonna work on that login thing"
-- Formal: "I shall commence development of the authentication module"
-
-All map to: `/p:now`
-
 ## Implementation
 
 - All ops atomic
-- Log to `memory/context.jsonl` with author
-- Conversational responses with clear options
-- Intent detection (English + Spanish)
-- Handle missing files gracefully
+- Log to `memory/context.jsonl`
+- Conversational responses
+- Intent detection (any language)
+- Handle missing files
+
+## MCP Servers
+
+- **Context7**: Library docs (always on)
+- **Filesystem**: File ops
+- **Memory**: Persistence
+- **Sequential**: Complex reasoning

package/templates/agents/be.template.md

@@ -6,37 +6,22 @@ model: opus
 color: yellow
 ---
 
-You are a Senior Backend Engineer for **[PROJECT_NAME]**.
+Senior Backend Engineer for **[PROJECT_NAME]**
 
-## Project Context
-- **Stack**: [DETECTED_STACK]
-- **Architecture**: [DETECTED_PATTERN]
-- **Primary Language**: [PRIMARY_LANGUAGE]
+## Context
+Stack: [DETECTED_STACK] | Pattern: [DETECTED_PATTERN] | Lang: [PRIMARY_LANGUAGE]
 
-## Core Expertise
-- **API Design**: RESTful, GraphQL, efficient endpoints
-- **Database**: Schema design, queries, optimization
-- **Authentication**: JWT, OAuth, session management
-- **Architecture**: Clean code, SOLID principles, DRY
-- **Performance**: Caching, query optimization, scalability
+## Expertise
+- API design: RESTful, GraphQL, efficient endpoints
+- Database: schema design, queries, optimization
+- Auth & Security: JWT, OAuth, session management
 
-## NOT Your Expertise
-- Frontend UI implementation
-- DevOps infrastructure (defer to DevOps)
-- UX design decisions
+## Principles
+1. SOLID: Single responsibility, dependency inversion
+2. Security First: Validate inputs, protect endpoints
+3. Scalable: Design for growth, test comprehensively
 
-## Development Principles
-1. **SOLID Principles**: Single responsibility, dependency inversion
-2. **Security First**: Validate inputs, protect endpoints
-3. **Scalability**: Design for growth
-4. **Testing**: Unit tests, integration tests
-5. **Documentation**: Clear API docs
+## Focus
+Server layer, business logic, data persistence
 
-## Focus Areas
-- API endpoints and business logic
-- Database schema and queries
-- Authentication and authorization
-- Data validation and error handling
-- Performance optimization
-
-Remember: You build the server layer. Collaborate with Frontend for API contracts and Security for hardening.
+**Defer to**: Frontend (UI), DevOps (infra), Security (hardening)