prjct-cli 0.13.3 → 0.15.1

package/packages/web/app/project/[id]/stats/page.tsx

@@ -1,253 +0,0 @@
-import { notFound } from 'next/navigation'
-import {
-  getStats,
-  getInsightMessage,
-  calculateStreak,
-  calculateHealthScore,
-  getVelocityChange,
-  getWeeklyVelocityData,
-  type StatsResult
-} from '@/lib/services/stats.server'
-import { getProject } from '@/lib/services/projects.server'
-import type { TimelineEvent } from '@/lib/parse-prjct-files'
-
-import { BentoGrid } from '@/components/BentoGrid'
-import { HeroSection } from '@/components/HeroSection'
-import { NowCard } from '@/components/NowCard'
-import { VelocityCard } from '@/components/VelocityCard'
-import { StreakCard } from '@/components/StreakCard'
-import { QueueCard } from '@/components/QueueCard'
-import { ShipsCard } from '@/components/ShipsCard'
-import { IdeasCard } from '@/components/IdeasCard'
-import { AgentsCard } from '@/components/AgentsCard'
-import { RoadmapCard } from '@/components/RoadmapCard'
-import { BlockersCard } from '@/components/BlockersCard'
-import { ActivityTimeline } from '@/components/ActivityTimeline'
-
-// Types for normalized component data
-interface NormalizedCurrentTask {
-  task: string
-  startedAt?: string
-  agent?: string
-  estimatedDuration?: string
-  pausedAt?: string
-  pauseReason?: string
-}
-
-interface NormalizedQueueItem {
-  task: string
-  priority?: 'low' | 'medium' | 'high' | 'critical' | number
-  estimatedDuration?: string
-}
-
-interface NormalizedShip {
-  name: string
-  date: string
-  duration?: string
-}
-
-interface NormalizedIdea {
-  title: string
-  impact?: string
-}
-
-interface NormalizedAgent {
-  name: string
-  description?: string
-  successRate?: number
-  tasksCompleted?: number
-  bestFor?: string[]
-}
-
-interface NormalizedRoadmap {
-  phases: Array<{
-    name: string
-    progress: number
-    features?: Array<{ name: string; status: string }>
-  }>
-  progress: number
-}
-
-// Data normalization functions
-function normalizeCurrentTask(stats: StatsResult): NormalizedCurrentTask | null {
-  if (stats.state?.currentTask) {
-    return {
-      task: stats.state.currentTask.description,
-      startedAt: stats.state.currentTask.startedAt,
-      // Simplified - removed legacy fields not in new schema
-    }
-  }
-  return stats.legacyStats?.currentTask ?? null
-}
-
-function normalizeQueue(stats: StatsResult): NormalizedQueueItem[] {
-  if (stats.queue?.tasks) {
-    return stats.queue.tasks
-      .filter(t => !t.completed)
-      .map(q => ({
-        task: q.description,
-        priority: q.priority,
-      }))
-  }
-  return stats.legacyStats?.queue ?? []
-}
-
-function normalizeRoadmap(stats: StatsResult): NormalizedRoadmap | null {
-  const features = stats.roadmap?.features ?? []
-  if (features.length > 0) {
-    const completed = features.filter(f =>
-      f.status === 'shipped' || f.status === 'completed'
-    ).length
-
-    return {
-      phases: features.map(f => ({
-        name: f.name,
-        progress: f.status === 'shipped' || f.status === 'completed' ? 100 :
-                  f.status === 'active' ? 50 : 0,
-        features: f.tasks.map(t => ({
-          name: t.description,
-          status: t.completed ? 'completed' : 'pending'
-        }))
-      })),
-      progress: Math.round((completed / features.length) * 100)
-    }
-  }
-  return stats.legacyStats?.roadmap ?? null
-}
-
-function normalizeShipped(stats: StatsResult): NormalizedShip[] {
-  const items = stats.shipped?.items ?? []
-  return items.map(s => ({
-    name: s.name,
-    date: s.shippedAt || s.date || new Date().toISOString(),
-  }))
-}
-
-function normalizeIdeas(stats: StatsResult): NormalizedIdea[] {
-  const ideas = stats.ideas?.ideas ?? []
-  return ideas
-    .filter(i => i.status === 'pending')
-    .map(i => ({
-      title: i.text,
-      impact: i.priority?.toUpperCase() || 'MEDIUM'
-    }))
-}
-
-function normalizeAgents(stats: StatsResult): NormalizedAgent[] {
-  return stats.agents.map(a => ({
-    name: a.name,
-    description: a.description,
-    successRate: a.successRate,
-    tasksCompleted: a.tasksCompleted,
-    bestFor: a.bestFor,
-  }))
-}
-
-function normalizeTimeline(stats: StatsResult): TimelineEvent[] {
-  if (stats.metrics?.recentActivity?.length) {
-    return stats.metrics.recentActivity.map(a => ({
-      ts: a.timestamp,
-      type: a.action || a.type || 'task_completed',
-      task: a.description || '',
-    }))
-  }
-  return stats.legacyStats?.timeline ?? []
-}
-
-function getVelocity(stats: StatsResult): number {
-  if (stats.metrics?.velocity?.tasksPerDay) {
-    return stats.metrics.velocity.tasksPerDay
-  }
-  return stats.legacyStats?.metrics?.velocity?.tasksPerDay ?? 0
-}
-
-function getTotalShips(stats: StatsResult): number {
-  return stats.shipped?.items?.length ?? stats.legacyStats?.summary?.totalShipsEver ?? 0
-}
-
-function getTasksCompleted(stats: StatsResult): number {
-  return stats.metrics?.currentSprint?.tasksCompleted ?? stats.legacyStats?.metrics?.tasksCompleted ?? 0
-}
-
-interface PageProps {
-  params: Promise<{ id: string }>
-}
-
-export default async function ProjectStatsPage({ params }: PageProps) {
-  const { id: projectId } = await params
-
-  // Fetch data directly on server - no API calls
-  const [project, stats] = await Promise.all([
-    getProject(projectId),
-    getStats(projectId)
-  ])
-
-  if (!stats.hasData) {
-    notFound()
-  }
-
-  // Compute derived values using service functions
-  const streak = calculateStreak(stats.metrics)
-  const healthScore = calculateHealthScore(stats)
-  const velocity = getVelocity(stats)
-  const velocityChange = getVelocityChange(velocity)
-  const insightMessage = getInsightMessage(stats, streak)
-  const weeklyVelocityData = getWeeklyVelocityData(stats.metrics)
-
-  // Normalize data for components
-  const currentTask = normalizeCurrentTask(stats)
-  const queue = normalizeQueue(stats)
-  const roadmap = normalizeRoadmap(stats)
-  const shipped = normalizeShipped(stats)
-  const ideas = normalizeIdeas(stats)
-  const agents = normalizeAgents(stats)
-  const timeline = normalizeTimeline(stats)
-  const totalShips = getTotalShips(stats)
-  const tasksCompleted = getTasksCompleted(stats)
-
-  // Extract insights
-  const { estimateAccuracy, blockers } = stats.insights
-
-  return (
-    <div className="flex h-full flex-col p-4 md:p-8 overflow-auto">
-      {/* Mobile: Add padding for hamburger menu */}
-      <div className="pl-10 md:pl-0">
-        <HeroSection
-          projectId={projectId}
-          projectName={project?.name ?? projectId}
-          tasksCompleted={tasksCompleted}
-          healthScore={healthScore}
-          velocity={velocity}
-          velocityChange={velocityChange}
-          insightMessage={insightMessage}
-          timeline={timeline}
-        />
-      </div>
-
-      {/* Bento Grid - Server Components */}
-      <BentoGrid className="mt-6 md:mt-8">
-        <NowCard currentTask={currentTask} />
-        <VelocityCard
-          tasksPerDay={velocity}
-          weeklyData={weeklyVelocityData}
-          change={velocityChange}
-          estimateAccuracy={estimateAccuracy}
-        />
-        <RoadmapCard roadmap={roadmap} />
-        <StreakCard streak={streak} />
-        <QueueCard queue={queue} />
-        <ShipsCard ships={shipped} totalShips={totalShips} />
-        <BlockersCard blockers={blockers} />
-        <IdeasCard ideas={ideas} />
-        <AgentsCard agents={agents} />
-      </BentoGrid>
-
-      {/* Activity Timeline - Client Component */}
-      <div className="mt-6 md:mt-8">
-        <ActivityTimeline timeline={timeline} />
-      </div>
-
-      <div className="h-6 md:h-8" />
-    </div>
-  )
-}

package/templates/agent-assignment.md

@@ -1,72 +0,0 @@
----
-name: agent-assignment
-description: Assign the best agent for a task
-allowed-tools: [Read]
----
-
-# Agent Assignment
-
-Select the best agent for the given task based on semantic understanding.
-
-## Input
-
-- **Task**: {{task}}
-- **Available Agents**: {{agents}}
-- **Project Context**: {{context}}
-
-## Instructions
-
-1. **Understand the Task**
-   - What domain does this task belong to?
-   - What skills are required?
-   - What is the complexity level?
-
-2. **Analyze Available Agents**
-   - Read each agent's expertise and domain
-   - Consider their skills and past success
-   - Match capabilities to task requirements
-
-3. **Select Best Agent**
-   - Choose the agent with highest relevance
-   - If multiple agents fit, prefer the specialist over generalist
-   - If no good match, use 'generalist' or 'full-stack'
-
-## Decision Criteria
-
-- **Domain Match**: Does the agent's domain align with the task?
-- **Skills Match**: Does the agent have the required skills?
-- **Complexity Fit**: Is the agent appropriate for this complexity level?
-
-## Output Format
-
-Return JSON with your decision:
-
-```json
-{
-  "agent": "agent-name",
-  "confidence": 0.85,
-  "reason": "Brief explanation of why this agent was selected",
-  "domain": "detected domain of the task"
-}
-```
-
-## Examples
-
-**Task**: "Implement React login component with form validation"
-**Decision**: `{ "agent": "frontend-specialist", "confidence": 0.95, "reason": "React component work requires frontend expertise", "domain": "frontend" }`
-
-**Task**: "Fix database connection timeout issue"
-**Decision**: `{ "agent": "backend-specialist", "confidence": 0.90, "reason": "Database issues require backend/infrastructure knowledge", "domain": "backend" }`
-
-**Task**: "Write unit tests for user service"
-**Decision**: `{ "agent": "qa-specialist", "confidence": 0.85, "reason": "Testing tasks benefit from QA expertise", "domain": "qa" }`
-
-**Task**: "Update README documentation"
-**Decision**: `{ "agent": "generalist", "confidence": 0.70, "reason": "Documentation is general task, no specialist needed", "domain": "docs" }`
-
-## Guidelines
-
-- Prefer specialists when task clearly fits their domain
-- Use generalist only when no specialist matches
-- Higher confidence = stronger match
-- Always provide a reason for transparency

package/templates/analysis/project-analysis.md

@@ -1,78 +0,0 @@
----
-allowed-tools: [Read, Glob, Bash]
-description: 'Analyze project technology stack - Claude reads and decides'
----
-
-# Project Analysis Instructions
-
-## Objective
-
-Determine the technology stack by READING actual files, not assuming.
-
-## Step 1: Read Dependency Files
-
-Read these files if they exist:
-
-- `package.json` → Node.js/JavaScript/TypeScript project
-- `Cargo.toml` → Rust project
-- `go.mod` → Go project
-- `requirements.txt` or `pyproject.toml` → Python project
-- `Gemfile` → Ruby project
-- `mix.exs` → Elixir project
-- `pom.xml` or `build.gradle` → Java project
-- `composer.json` → PHP project
-
-**Extract actual dependencies** - don't guess frameworks.
-
-## Step 2: Examine Directory Structure
-
-List the root directory to identify:
-
-- Source directories (src/, lib/, app/, cmd/)
-- Test directories (tests/, spec/, __tests__/)
-- Config directories (.github/, .gitlab/, .vscode/)
-- Build outputs (dist/, build/, target/)
-
-## Step 3: Check Configuration Files
-
-Look for:
-
-- `tsconfig.json` → TypeScript configuration
-- `Dockerfile` → Docker usage
-- `docker-compose.yml` → Multi-container setup
-- `.eslintrc`, `.prettierrc` → Linting/formatting
-- `jest.config.js`, `vitest.config.ts` → Testing setup
-- `.env*` files → Environment configuration
-
-## Step 4: Determine Stack
-
-Based on what you READ (not assumed):
-
-1. **Languages**: Identify from file extensions and configs
-2. **Frameworks**: Extract from actual dependencies
-3. **Tools**: Identify from config files present
-4. **Databases**: Look for DB clients in dependencies
-5. **Testing**: Identify test frameworks from configs/deps
-
-## Output Format
-
-Provide analysis in this structure:
-
-```json
-{
-  "languages": ["actual languages found"],
-  "frameworks": ["actual frameworks from deps"],
-  "tools": ["tools with config files present"],
-  "databases": ["database clients in deps"],
-  "testing": ["test frameworks found"],
-  "notes": "any observations about the project"
-}
-```
-
-## Rules
-
-- **NO hardcoded assumptions** - React doesn't mean "frontend"
-- **READ before deciding** - Don't guess based on filenames
-- **Any stack works** - Elixir, Rust, Go, Python, etc.
-- **Be specific** - Include versions when available
-- **Note uncertainty** - If unclear, say so

package/templates/checklists/accessibility.md

@@ -1,33 +0,0 @@
-# Accessibility Checklist
-
-> Applies to: Web (WCAG), Mobile, CLI, Desktop
-
-## Perceivable
-- [ ] Text alternatives for non-text content
-- [ ] Sufficient color contrast (4.5:1 minimum)
-- [ ] Content readable without color alone
-- [ ] Resizable text supported (up to 200%)
-
-## Operable
-- [ ] Keyboard accessible (all functionality)
-- [ ] No keyboard traps
-- [ ] Sufficient time for interactions
-- [ ] Seizure-safe (no flashing > 3Hz)
-
-## Understandable
-- [ ] Clear and simple language
-- [ ] Consistent navigation
-- [ ] Input assistance provided
-- [ ] Error identification and suggestions
-
-## Robust
-- [ ] Compatible with assistive technologies
-- [ ] Valid markup/structure
-- [ ] ARIA used correctly (web)
-- [ ] Semantic HTML elements used
-
-## CLI Accessibility
-- [ ] Screen reader compatible output
-- [ ] No color-only information
-- [ ] Clear text formatting
-- [ ] Configurable output verbosity

package/templates/commands/build.md

@@ -1,17 +0,0 @@
----
-allowed-tools: [Read, Write, GetTimestamp]
-description: 'Start task'
-timestamp-rule: 'GetTimestamp() for id and started'
----
-
-# /p:build
-
-## Check
-Block if `core/now.md` active
-
-## Flow
-1. Parse task/# → Detect agent + complexity
-2. Write now.md: id={GetTimestamp()}, agent, started={GetTimestamp()}
-
-## Response
-`🎯 {task} | {agent} | Est: {time} | Done: /p:done`

package/templates/commands/decision.md

@@ -1,226 +0,0 @@
----
-allowed-tools: [Read, Write, Bash]
-description: 'Log architectural or important decisions'
-timestamp-rule: 'GetTimestamp() for ALL timestamps'
-architecture: 'MD-first - MD files are source of truth'
----
-
-# /p:decision - Log Important Decisions
-
-## Architecture: MD-First
-
-**Source of Truth**: `planning/decisions.md`
-
-MD files are the source of truth. Write directly to MD files.
-
-## Context Variables
-- `{projectId}`: From `.prjct/prjct.config.json`
-- `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
-- `{decisionsPath}`: `{globalPath}/planning/decisions.md`
-- `{memoryPath}`: `{globalPath}/memory/context.jsonl`
-- `{decision}`: User-provided decision (required)
-- `{reasoning}`: User-provided reasoning (optional)
-- `{alternatives}`: User-provided alternatives considered (optional)
-
-## Decision Format
-
-Capture WHY decisions were made to avoid repeating mistakes:
-
-```
-/p:decision "Use REST instead of GraphQL"
-  --reason "Simpler for this use case, team familiarity"
-  --alternatives "GraphQL, gRPC"
-```
-
-Or interactive prompt:
-```
-Decision: Use REST instead of GraphQL
-
-Why did you make this decision?
-> Simpler for this use case, team familiarity
-
-What alternatives did you consider?
-> GraphQL, gRPC
-```
-
-## Step 1: Read Config
-
-READ: `.prjct/prjct.config.json`
-EXTRACT: `projectId`
-
-IF file not found:
-  OUTPUT: "No prjct project. Run /p:init first."
-  STOP
-
-## Step 2: Validate Input
-
-IF {decision} is empty:
-  ASK: "What decision did you make?"
-  SET: {decision} = user response
-
-IF {reasoning} is empty:
-  ASK: "Why did you make this decision?"
-  SET: {reasoning} = user response
-
-IF {alternatives} is empty:
-  ASK: "What alternatives did you consider? (optional, press Enter to skip)"
-  SET: {alternatives} = user response OR "none documented"
-
-## Step 3: Generate Decision Entry
-
-GENERATE: {decisionId} = "dec_" + 8 random alphanumeric chars
-SET: {now} = GetTimestamp()
-
-## Step 4: Read/Create Decisions File
-
-READ: `{decisionsPath}` (or create default if not exists)
-
-Default structure:
-```markdown
-# Decisions
-
-Architecture decisions and their reasoning.
-
-## Recent
-
-_No decisions logged yet_
-
-## Archive
-
-_No archived decisions_
-```
-
-## Step 5: Update Decisions File (MD)
-
-Parse existing content and add new decision under "## Recent" section:
-
-```markdown
-# Decisions
-
-Architecture decisions and their reasoning.
-
-## Recent
-
-### {decision}
-- **ID**: {decisionId}
-- **Date**: {now}
-- **Reasoning**: {reasoning}
-- **Alternatives**: {alternatives}
-- **Context**: {current task from now.md if active}
-
-{...existing recent decisions}
-
-## Archive
-
-{...existing archive}
-```
-
-WRITE: `{decisionsPath}`
-
-## Step 6: Log to Memory
-
-APPEND to: `{memoryPath}`
-
-Single line (JSONL):
-```json
-{"timestamp":"{now}","action":"decision_logged","decisionId":"{decisionId}","decision":"{decision}","reasoning":"{reasoning}","alternatives":"{alternatives}"}
-```
-
-## Output
-
-SUCCESS:
-```
-📝 Decision logged: {decision}
-
-ID: {decisionId}
-Reasoning: {reasoning}
-Alternatives: {alternatives}
-
-Next:
-• Continue working on your task
-• /p:recap - Review decisions made
-```
-
-## Error Handling
-
-| Error | Response | Action |
-|-------|----------|--------|
-| No project | "No prjct project" | STOP |
-| No decision provided | Ask for decision | WAIT |
-| Write fails | Log warning | CONTINUE |
-
-## Examples
-
-### Example 1: Full Decision with All Fields
-**Input:** `/p:decision "Use Zustand for state management" --reason "Lighter than Redux, better DX" --alternatives "Redux, MobX, Jotai"`
-
-**Output:**
-```
-📝 Decision logged: Use Zustand for state management
-
-ID: dec_abc12345
-Reasoning: Lighter than Redux, better DX
-Alternatives: Redux, MobX, Jotai
-
-Next: Continue working | /p:recap
-```
-
-### Example 2: Interactive Mode
-**Input:** `/p:decision`
-
-**Prompt flow:**
-```
-What decision did you make?
-> Use PostgreSQL instead of MongoDB
-
-Why did you make this decision?
-> Need relational data with joins, better ACID compliance
-
-What alternatives did you consider? (Enter to skip)
-> MongoDB, SQLite
-```
-
-**Output:**
-```
-📝 Decision logged: Use PostgreSQL instead of MongoDB
-
-ID: dec_xyz98765
-Reasoning: Need relational data with joins, better ACID compliance
-Alternatives: MongoDB, SQLite
-
-Next: Continue working | /p:recap
-```
-
-### Example 3: Quick Decision (minimal)
-**Input:** `/p:decision "Skip tests for MVP"`
-
-**Prompt:**
-```
-Why did you make this decision?
-> Time constraint, will add before launch
-```
-
-**Output:**
-```
-📝 Decision logged: Skip tests for MVP
-
-ID: dec_qrs45678
-Reasoning: Time constraint, will add before launch
-Alternatives: none documented
-
-Next: Continue working | /p:recap
-```
-
-## Use Cases
-
-When to log a decision:
-- Choosing between technologies/libraries
-- Architectural pattern selection
-- Trade-off decisions (speed vs quality)
-- Deviation from best practices (and why)
-- Postponing technical debt intentionally
-
-This creates institutional memory to avoid:
-- Repeating the same debates
-- Forgetting why something was done a certain way
-- Making inconsistent choices across the codebase