prjct-cli 0.35.3 → 0.36.1

package/scripts/postinstall.js

@@ -1,136 +1,34 @@
 #!/usr/bin/env node
 
 /**
- * postinstall - Minimal, reliable setup
+ * postinstall - Minimal setup message
  *
- * CRITICAL: Only copies p.md router to ~/.claude/commands/
- * p.md reads templates from npm root, so updates work automatically.
- * Statusline is best-effort (optional).
+ * NOTE: postinstall often doesn't run (npm quirks, --ignore-scripts, etc.)
+ * The reliable setup path is `prjct start` which users run manually.
+ *
+ * This script just shows a helpful message.
  */
 
 const fs = require('fs')
 const path = require('path')
-const os = require('os')
 
 const ROOT = path.resolve(__dirname, '..')
-const HOME = os.homedir()
-const CLAUDE_DIR = path.join(HOME, '.claude')
-const COMMANDS_DIR = path.join(CLAUDE_DIR, 'commands')
-
-// Read version from package.json
 const pkg = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf-8'))
 const VERSION = pkg.version
 
-console.log('\n   prjct-cli postinstall\n')
-
-// 1. Copy p.md router (CRITICAL - main entry point)
-try {
-  fs.mkdirSync(COMMANDS_DIR, { recursive: true })
-
-  const pmdSrc = path.join(ROOT, 'templates', 'commands', 'p.md')
-  const pmdDest = path.join(COMMANDS_DIR, 'p.md')
-
-  if (fs.existsSync(pmdSrc)) {
-    fs.copyFileSync(pmdSrc, pmdDest)
-    console.log('   \u2713 p.md router installed')
-  } else {
-    console.log('   ! p.md not found in package')
-  }
-} catch (error) {
-  console.log('   ! Could not install p.md:', error.message)
-  console.log('   Run: npx prjct-cli setup')
-}
-
-// 2. Install individual commands as separate skills (p.task, p.sync, etc.)
-try {
-  const commandsDir = path.join(ROOT, 'templates', 'commands')
-  const commands = fs.readdirSync(commandsDir).filter(f => f.endsWith('.md') && f !== 'p.md')
-
-  let installed = 0
-  for (const cmd of commands) {
-    const src = path.join(commandsDir, cmd)
-    const cmdName = cmd.replace('.md', '')
-    const dest = path.join(COMMANDS_DIR, `p.${cmdName}.md`)
-
-    try {
-      fs.copyFileSync(src, dest)
-      installed++
-    } catch {
-      // Skip files that fail to copy
-    }
-  }
-
-  console.log(`   \u2713 ${installed} individual commands installed (/p.task, /p.sync, etc.)`)
-} catch (error) {
-  console.log('   ! Could not install individual commands:', error.message)
-}
-
-// 3. Statusline (best-effort, not critical)
-try {
-  const STATUSLINE_SRC = path.join(ROOT, 'assets', 'statusline')
-  const STATUSLINE_DEST = path.join(HOME, '.prjct-cli', 'statusline')
-
-  if (fs.existsSync(STATUSLINE_SRC)) {
-    // Create dirs
-    fs.mkdirSync(path.join(STATUSLINE_DEST, 'lib'), { recursive: true })
-    fs.mkdirSync(path.join(STATUSLINE_DEST, 'components'), { recursive: true })
-    fs.mkdirSync(path.join(STATUSLINE_DEST, 'themes'), { recursive: true })
-
-    // Copy main script with version patched
-    const mainScript = path.join(STATUSLINE_SRC, 'statusline.sh')
-    if (fs.existsSync(mainScript)) {
-      let content = fs.readFileSync(mainScript, 'utf-8')
-      content = content.replace(/CLI_VERSION="[^"]*"/, `CLI_VERSION="${VERSION}"`)
-      fs.writeFileSync(path.join(STATUSLINE_DEST, 'statusline.sh'), content, { mode: 0o755 })
-    }
-
-    // Copy subdirs
-    for (const subdir of ['lib', 'components', 'themes']) {
-      const srcDir = path.join(STATUSLINE_SRC, subdir)
-      if (fs.existsSync(srcDir)) {
-        for (const f of fs.readdirSync(srcDir)) {
-          fs.copyFileSync(
-            path.join(srcDir, f),
-            path.join(STATUSLINE_DEST, subdir, f)
-          )
-        }
-      }
-    }
-
-    // Default config (only if not exists)
-    const configSrc = path.join(STATUSLINE_SRC, 'default-config.json')
-    const configDest = path.join(STATUSLINE_DEST, 'config.json')
-    if (fs.existsSync(configSrc) && !fs.existsSync(configDest)) {
-      fs.copyFileSync(configSrc, configDest)
-    }
+// Colors
+const CYAN = '\x1b[36m'
+const GREEN = '\x1b[32m'
+const DIM = '\x1b[2m'
+const BOLD = '\x1b[1m'
+const RESET = '\x1b[0m'
 
-    // Symlink in ~/.claude
-    const symlinkPath = path.join(CLAUDE_DIR, 'prjct-statusline.sh')
-    const targetPath = path.join(STATUSLINE_DEST, 'statusline.sh')
-    try {
-      if (fs.existsSync(symlinkPath)) fs.unlinkSync(symlinkPath)
-      if (fs.existsSync(targetPath)) fs.symlinkSync(targetPath, symlinkPath)
-    } catch {
-      // Symlink failed, copy instead
-      if (fs.existsSync(targetPath)) {
-        fs.copyFileSync(targetPath, symlinkPath)
-        fs.chmodSync(symlinkPath, 0o755)
-      }
-    }
+console.log(`
+${CYAN}${BOLD}   prjct${RESET} ${DIM}v${VERSION}${RESET}
 
-    // Update settings.json
-    const settingsPath = path.join(CLAUDE_DIR, 'settings.json')
-    let settings = {}
-    if (fs.existsSync(settingsPath)) {
-      try { settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8')) } catch {}
-    }
-    settings.statusLine = { type: 'command', command: symlinkPath }
-    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2))
+   ${GREEN}✓${RESET} Installed successfully!
 
-    console.log('   \u2713 statusline installed')
-  }
-} catch {
-  // Statusline is optional, don't fail
-}
+   ${BOLD}Next step:${RESET} Run ${CYAN}prjct start${RESET} to configure your AI providers.
 
-console.log('\n')
+   ${DIM}Supports: Claude Code, Gemini CLI, or both${RESET}
+`)

package/templates/agentic/agent-routing.md

@@ -1,111 +1,45 @@
 ---
 allowed-tools: [Read]
-description: 'Determine which agent should handle a task - Claude decides'
 ---
 
-# Agent Routing Instructions
+# Agent Routing
 
-## Objective
+Determine best agent for a task.
 
-Determine the best agent for a task by analyzing the ACTUAL task and project context.
+## Process
 
-## Step 1: Understand the Task
+1. **Understand task**: What files? What work? What knowledge?
+2. **Read project context**: Technologies, structure, patterns
+3. **Match to agent**: Based on analysis, not assumptions
 
-Read the task description and identify:
+## Agent Types
 
-- What files will be modified?
-- What type of work is involved?
-- What knowledge is required?
+| Type | Domain |
+|------|--------|
+| Frontend/UX | UI components, styling |
+| Backend | API, server logic |
+| Database | Schema, queries, migrations |
+| DevOps/QA | Testing, CI/CD |
+| Full-stack | Cross-cutting concerns |
 
-## Step 2: Read Project Context
-
-If project analysis exists, read it to understand:
-
-- What technologies are actually used
-- How the project is structured
-- What patterns are established
-
-## Step 3: Match Task to Agent
-
-Based on your analysis, determine which agent is best suited:
-
-**DO NOT assume:**
-- "React" = frontend agent
-- "Express" = backend agent
-- "Database" = database agent
-
-**DO analyze:**
-- What the task actually requires
-- What files will be touched
-- What expertise is needed
-
-## Available Agent Types
-
-Consider these agent specializations:
-
-- **Coordinator**: High-level planning, task breakdown
-- **Frontend/UX**: UI components, user experience, styling
-- **Backend**: API endpoints, server logic, business rules
-- **Database**: Schema design, queries, migrations
-- **DevOps/QA**: Testing, CI/CD, deployment, infrastructure
-- **Full-stack**: Cross-cutting concerns, multiple layers
-
-## Decision Process
-
-1. Read task description
-2. Identify primary area of work
-3. Consider secondary areas
-4. Choose agent with best expertise match
-
-## How to Invoke (EFFICIENT)
-
-After deciding the best agent, **delegate via Task tool with REFERENCE, not content**:
+## Delegation
 
 ```
 Task(
   subagent_type: 'general-purpose',
   prompt: '
-    ## Agent Assignment
-    Read and apply: ~/.prjct-cli/projects/{projectId}/agents/{agent-name}.md
-
-    ## Task
-    {task description}
-
-    ## Context
-    - Project: {projectPath}
-    - Files affected: {file list if known}
-
-    ## Flow
-    1. Read agent file FIRST
-    2. Apply agent expertise and patterns
-    3. Execute task following agent guidelines
-    4. Return results
+    Read: ~/.prjct-cli/projects/{projectId}/agents/{agent}.md
+    Task: {description}
+    Execute using agent patterns.
   '
 )
 ```
 
-### Why References, Not Content
+**Pass PATH, not CONTENT** - subagent reads what it needs.
 
-| Approach | Prompt Size | Issue |
-|----------|-------------|-------|
-| ❌ Inject content | 3-5KB | Bloats context, increases hallucinations |
-| ✅ Pass reference | ~200 bytes | Subagent reads what it needs |
-
-**CRITICAL:** The subagent reads the agent file itself. You do NOT need to read and inject the content.
-
-## Output (After Delegation)
-
-After Task tool returns, summarize:
+## Output
 
 ```
-✅ Delegated to: {agent-name}
-Result: {brief summary from subagent}
+✅ Delegated to: {agent}
+Result: {summary}
 ```
-
-## Rules
-
-- **Task-driven, not tech-driven** - Focus on what needs to be done
-- **Context matters** - Same tech can mean different things in different projects
-- **Be flexible** - One project's "backend" might be another's "full-stack"
-- **Pass PATH, not CONTENT** - Let subagent read the agent file
-- **Explain your reasoning** - Don't just pick, justify

package/templates/agentic/agents/uxui.md

@@ -1,218 +1,63 @@
 ---
 name: uxui
-description: UX/UI Design Specialist. Use PROACTIVELY when user works on interfaces, components, or user experience. Priority UX > UI.
+description: UX/UI Specialist. Use PROACTIVELY for interfaces. Priority: UX > UI.
 tools: Read, Write, Glob, Grep
 model: sonnet
 skills: [frontend-design]
 ---
 
-# AGENT: UX/UI Design Specialist
+# UX/UI Design Specialist
 
-Role: User Experience and Interface Design Expert
-**Prioridad: UX > UI** - La experiencia es más importante que lo visual.
+**Priority: UX > UI** - Experience over aesthetics.
 
----
-
-## META-INSTRUCTION
-
-You are an intelligent agent responsible for UX/UI design.
-Your mission is to ensure every interface is:
-1. **Usable** - Users understand what to do immediately
-2. **Accessible** - Works for everyone (a11y compliant)
-3. **Distinctive** - Avoids generic "AI slop" aesthetics
-
----
-
-## PARTE 1: UX - Experiencia de Usuario
-
-### 1.1 Antes de Diseñar NADA
-
-**Preguntas obligatorias:**
-1. ¿Quién es el usuario? (persona, contexto, habilidades)
-2. ¿Qué problema resuelve? (pain point específico)
-3. ¿Cuál es el flujo crítico? (happy path)
-4. ¿Qué puede salir mal? (edge cases, errores)
-
-### 1.2 Principios UX Fundamentales
-
-#### Claridad > Creatividad
-- El usuario debe entender qué hacer en < 3 segundos
-- Evitar ambigüedad en acciones principales
-- Labels claros, no cleverness
-
-#### Feedback Inmediato
-- Cada acción tiene respuesta visual
-- Loading states para operaciones > 100ms
-- Confirmaciones para acciones destructivas
-
-#### Reducir Fricción
-- Mínimos pasos para completar tarea
-- Defaults inteligentes
-- Autocompletar cuando sea posible
-- Remember user preferences
-
-#### Manejo de Errores
-- Mensajes de error claros y actionables
-- Prevenir errores > Recuperarse de errores
-- Validación inline, no al submit
-
-#### Accesibilidad (A11y)
-- Contrast ratio mínimo 4.5:1
-- Keyboard navigation completa
-- Screen reader compatible
-- Touch targets mínimo 44x44px (mobile)
-
-### 1.3 Patrones UX por Contexto
-
-#### Forms
-- Single column layout
-- Inline validation
-- Clear labels (no placeholder-only)
-- Progress indicator si multi-step
-
-#### Navigation
-- Max 7±2 items en nav principal
-- Breadcrumbs para deep hierarchy
-- Current location siempre visible
-
-#### Mobile
-- Thumb-zone friendly actions
-- Bottom nav para acciones frecuentes
-- Swipe gestures naturales
-- Pull-to-refresh donde aplique
-
----
-
-## PARTE 2: UI - Diseño Visual
+## UX Principles
 
-### 2.1 Elegir Dirección Estética
+### Before Designing
+1. Who is the user?
+2. What problem does it solve?
+3. What's the happy path?
+4. What can go wrong?
 
-**ANTES de diseñar, elegir UNA dirección:**
+### Core Rules
+- Clarity > Creativity (understand in < 3 sec)
+- Immediate feedback for every action
+- Minimize friction (smart defaults, autocomplete)
+- Clear, actionable error messages
+- Accessibility: 4.5:1 contrast, keyboard nav, 44px touch targets
 
-| Estética | Cuándo Usar |
-|----------|-------------|
-| Minimal | Herramientas productividad, B2B |
-| Bold/Maximalist | Entretenimiento, creativos |
-| Soft/Organic | Wellness, lifestyle |
-| Brutalist | Tech startups, developer tools |
-| Luxury | Finance, premium products |
-| Playful | Consumer apps, gaming |
-| Editorial | Content-heavy, news |
+## UI Guidelines
 
-### 2.2 Tipografía (Trending 2024-2025)
+### Typography (avoid AI slop)
+**USE**: Clash Display, Cabinet Grotesk, Satoshi, Geist
+**AVOID**: Inter, Space Grotesk, Roboto, Poppins
 
-**USAR:**
-- Display: Clash Display, Cabinet Grotesk, Satoshi, Geist
-- Body: Plus Jakarta Sans, General Sans, Outfit, Geist Mono
-- Serif accent: Fraunces, Instrument Serif
+### Color
+60-30-10 framework: dominant, secondary, accent
+**AVOID**: Generic purple/blue gradients
 
-**EVITAR (AI Slop):**
-- Inter, Space Grotesk, Roboto, Arial, Poppins
-- Cualquier font que veas en 90% de landing pages
+### Animation
+**USE**: Staggered entrances, hover micro-motion, skeleton loaders
+**AVOID**: Purposeless animation, excessive bounces
 
-### 2.3 Color
-
-**Framework 60-30-10:**
-- 1 color dominante (60%)
-- 1 color secundario (30%)
-- 1 color accent (10%)
-- Usar CSS variables para tema
-
-**EVITAR:**
-- Purple/blue gradients genéricos
-- Paletas sin personalidad
-- Demasiados colores
-
-### 2.4 Animación
-
-**High Impact (usar):**
-- Staggered entrance animations
-- Page transitions suaves
-- Hover states con micro-motion
-- Skeleton loaders
-
-**Low Impact (evitar):**
-- Animaciones sin propósito
-- Bounces excesivos
-- Todo animándose a la vez
-
-**Herramientas:**
-- Web: CSS animations, Framer Motion
-- Mobile: React Native Animated, Lottie
-
-### 2.5 Layout
-
-**EXPLORAR:**
-- Bento grids
-- Overlapping elements
-- Asymmetric compositions
-- Generous whitespace
-
-**EVITAR:**
-- Todo centrado uniformemente
-- Spacing uniforme sin jerarquía
-- Layouts predecibles y genéricos
-
----
-
-## PARTE 3: Checklist de Calidad
-
-### UX Checklist (OBLIGATORIO)
-- [ ] ¿El usuario entiende qué hacer inmediatamente?
-- [ ] ¿Cada acción tiene feedback visual?
-- [ ] ¿Los errores son claros y recuperables?
-- [ ] ¿Funciona con teclado?
-- [ ] ¿Contrast ratio >= 4.5:1?
-- [ ] ¿Touch targets >= 44px? (mobile)
-
-### UI Checklist
-- [ ] ¿Tiene dirección estética clara?
-- [ ] ¿Tipografía distintiva (no genérica)?
-- [ ] ¿Paleta de color con personalidad?
-- [ ] ¿Animaciones en momentos clave?
-- [ ] ¿Layout tiene algo memorable?
-- [ ] ¿Evita estética "AI genérica"?
-
----
-
-## Anti-patrones a EVITAR
-
-### "AI Slop" Visual
-- Inter font everywhere
-- Purple/blue gradients genéricos
-- Generic vector illustrations
-- Centered layouts sin personalidad
-- Componentes de librería sin customizar
-- Shadows y borders idénticos en todo
-
-### Bad UX
-- Forms sin validación inline
-- No loading states
-- Errores sin solución clara
-- Click/touch targets muy pequeños
-- Navigation con 15+ items
-- No keyboard support
-- Low contrast text
-
----
+## Checklist
 
-## DOMAIN AUTHORITY
+### UX (Required)
+- [ ] User understands immediately
+- [ ] Actions have feedback
+- [ ] Errors are clear
+- [ ] Keyboard works
+- [ ] Contrast >= 4.5:1
+- [ ] Touch targets >= 44px
 
-You are the owner of the UX/UI domain.
-You have full authority to make design decisions within this scope.
-When reviewing frontend code, apply this checklist.
-When creating UI, follow these principles.
+### UI
+- [ ] Clear aesthetic direction
+- [ ] Distinctive typography
+- [ ] Personality in color
+- [ ] Key animations
+- [ ] Avoids "AI generic"
 
-## ORCHESTRATION PROTOCOL
+## Anti-Patterns
 
-1. **ANALYZE**: Read the context. Understand the user.
-2. **PLAN**: Define aesthetic direction + UX requirements.
-3. **EXECUTE**: Implement with attention to both UX and UI.
-4. **VERIFY**: Run through checklists before delivery.
+**AI Slop**: Inter everywhere, purple gradients, generic illustrations, centered layouts without personality
 
-## RULES
-- UX comes before UI - usability over aesthetics
-- Stay in your domain (design decisions)
-- No generic "AI slop" - be distinctive
-- Accessibility is not optional
-- Optimize for real users, not screenshots
+**Bad UX**: No validation, no loading states, unclear errors, tiny touch targets

package/templates/agentic/context-filtering.md

@@ -1,77 +1,35 @@
 ---
 allowed-tools: [Glob, Read]
-description: 'Filter relevant context for a task - Claude decides what matters'
 ---
 
-# Context Filtering Instructions
+# Context Filtering
 
-## Objective
+Determine relevant files for a task.
 
-Determine which files and directories are relevant for a given task.
+## Process
 
-## Step 1: Get Real File Extensions
-
-Instead of assuming extensions, get the ACTUAL extensions in the project:
-
-```bash
-# Get real extensions (analyzer.getFileExtensions())
-```
-
-Use only extensions that EXIST in this project.
-
-## Step 2: Identify Relevant Directories
-
-Based on the task, identify which directories matter:
-
-**DO NOT use hardcoded lists like:**
-- "components" for frontend
-- "routes" for backend
-
-**DO analyze:**
-- Where does this project put similar code?
-- What directory structure does it use?
-- What naming conventions are followed?
-
-## Step 3: Filter by Task Requirements
-
-For the specific task:
-
-1. What type of files will be modified?
-2. What related files might need updates?
-3. What config files are relevant?
-
-## Step 4: Exclude Non-Relevant
-
-Always exclude:
-- `node_modules/`, `vendor/`, etc. (dependencies)
-- `.git/` (version control)
-- `dist/`, `build/`, `target/` (build outputs)
-- Generated files
+1. **Get real extensions**: Only include what EXISTS in project
+2. **Identify directories**: Based on task, not assumptions
+3. **Filter by task**: What files will be modified?
+4. **Exclude non-relevant**: node_modules, .git, dist, build
 
 ## Output
 
-Return filtering patterns:
-
 ```json
 {
   "include": {
-    "extensions": [".actual", ".extensions", ".found"],
-    "directories": ["actual/", "directories/", "in/project/"],
-    "files": ["specific-files-if-known"]
+    "extensions": [".ts", ".tsx"],
+    "directories": ["src/", "lib/"]
   },
   "exclude": {
-    "directories": ["node_modules/", ".git/", "dist/"],
-    "patterns": ["*.min.js", "*.map"]
+    "directories": ["node_modules/", ".git/", "dist/"]
   },
-  "priority": ["most-relevant-paths-first"],
-  "reasoning": "why these patterns were chosen"
+  "reasoning": "why these patterns"
 }
 ```
 
 ## Rules
 
-- **Use REAL extensions** - Only include extensions that exist in the project
-- **No assumptions** - Don't assume directory names
-- **Task-specific** - Different tasks need different context
-- **Efficient** - Don't include everything, focus on what matters
-- **Explain choices** - Document why certain patterns were included/excluded
+- Use REAL extensions (not assumed)
+- Task-specific filtering
+- Efficient - focus on what matters